From b43fea0e0c5e611331611cec3b015ba31a0fde93 Mon Sep 17 00:00:00 2001 From: Olivier Blanvillain Date: Mon, 22 May 2017 09:55:19 +0200 Subject: [PATCH 001/220] Update docs --- docs/book/Cats.html | 405 ++++++++++ docs/book/FeatureOverview.html | 717 ++++++++++++++++++ docs/book/Injection.html | 409 ++++++++++ docs/book/Job.html | 369 +++++++++ docs/book/TypedDataFrame.html | 417 ++++++++++ docs/book/TypedDatasetVsSparkDataset.html | 532 +++++++++++++ docs/book/TypedEncoder.html | 378 +++++++++ .../gitbook/fonts/fontawesome/FontAwesome.otf | Bin 0 -> 124988 bytes .../fonts/fontawesome/fontawesome-webfont.eot | Bin 0 -> 76518 bytes .../fonts/fontawesome/fontawesome-webfont.svg | 685 +++++++++++++++++ .../fonts/fontawesome/fontawesome-webfont.ttf | Bin 0 -> 152796 bytes .../fontawesome/fontawesome-webfont.woff | Bin 0 -> 90412 bytes .../fontawesome/fontawesome-webfont.woff2 | Bin 0 -> 71896 bytes .../fontsettings.js | 240 ++++++ .../gitbook-plugin-fontsettings/website.css | 291 +++++++ .../gitbook-plugin-highlight/ebook.css | 135 ++++ .../gitbook-plugin-highlight/website.css | 434 +++++++++++ .../gitbook/gitbook-plugin-lunr/lunr.min.js | 7 + .../gitbook-plugin-lunr/search-lunr.js | 59 ++ .../gitbook/gitbook-plugin-search/lunr.min.js | 7 + .../gitbook-plugin-search/search-engine.js | 50 ++ .../gitbook/gitbook-plugin-search/search.css | 35 + .../gitbook/gitbook-plugin-search/search.js | 213 ++++++ .../gitbook/gitbook-plugin-sharing/buttons.js | 90 +++ docs/book/gitbook/gitbook.js | 4 + .../apple-touch-icon-precomposed-152.png | Bin 0 -> 4817 bytes docs/book/gitbook/images/favicon.ico | Bin 0 -> 4286 bytes docs/book/gitbook/style.css | 9 + docs/book/gitbook/theme.js | 4 + docs/book/index.html | 386 ++++++++++ docs/book/search_index.json | 1 + docs/src/main/tut/README.md | 86 +++ 32 files changed, 5963 insertions(+) create mode 100644 docs/book/Cats.html create mode 100644 docs/book/FeatureOverview.html create mode 100644 docs/book/Injection.html create mode 100644 docs/book/Job.html create mode 100644 docs/book/TypedDataFrame.html create mode 100644 docs/book/TypedDatasetVsSparkDataset.html create mode 100644 docs/book/TypedEncoder.html create mode 100644 docs/book/gitbook/fonts/fontawesome/FontAwesome.otf create mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.eot create mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.svg create mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.ttf create mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff create mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff2 create mode 100644 docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js create mode 100644 docs/book/gitbook/gitbook-plugin-fontsettings/website.css create mode 100644 docs/book/gitbook/gitbook-plugin-highlight/ebook.css create mode 100644 docs/book/gitbook/gitbook-plugin-highlight/website.css create mode 100644 docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js create mode 100644 docs/book/gitbook/gitbook-plugin-lunr/search-lunr.js create mode 100644 docs/book/gitbook/gitbook-plugin-search/lunr.min.js create mode 100644 docs/book/gitbook/gitbook-plugin-search/search-engine.js create mode 100644 docs/book/gitbook/gitbook-plugin-search/search.css create mode 100644 docs/book/gitbook/gitbook-plugin-search/search.js create mode 100644 docs/book/gitbook/gitbook-plugin-sharing/buttons.js create mode 100644 docs/book/gitbook/gitbook.js create mode 100644 docs/book/gitbook/images/apple-touch-icon-precomposed-152.png create mode 100644 docs/book/gitbook/images/favicon.ico create mode 100644 docs/book/gitbook/style.css create mode 100644 docs/book/gitbook/theme.js create mode 100644 docs/book/index.html create mode 100644 docs/book/search_index.json create mode 100644 docs/src/main/tut/README.md diff --git a/docs/book/Cats.html b/docs/book/Cats.html new file mode 100644 index 000000000..75301856d --- /dev/null +++ b/docs/book/Cats.html @@ -0,0 +1,405 @@ + + + + + + + Using Cats with RDDs · GitBook + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+ + + + + + + + +
+ +
+ +
+ + + + + + + + +
+
+ +
+
+ +
+ +

Using Cats with RDDs

+

Data aggregation is one of the most important operations when working with Spark (and data in general). +For example, we often have to compute the min, max, avg, etc. from a set of columns grouped by +different predicates. This section shows how cats simplifies these tasks in Spark by +leveraging a large collection of Type Classes for ordering and aggregating data.

+

All the examples below assume you have previously imported cats.implicits.

+
import cats.implicits._
+// import cats.implicits._
+
+

Cats offers ways to sort and aggregate tuples of arbitrary arity.

+
import frameless.cats.implicits._
+// import frameless.cats.implicits._
+
+val data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)
+// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[0] at makeRDD at <console>:21
+
+println(data.csum)
+// (10,9,9)
+
+println(data.cmax)
+// (8,2,3)
+
+println(data.cmin)
+// (1,2,3)
+
+

The following example aggregates all the elements with a common key.

+
type User = String
+// defined type alias User
+
+type TransactionCount = Int
+// defined type alias TransactionCount
+
+val allData: RDD[(User,TransactionCount)] =
+   sc.makeRDD(("Bob", 12) :: ("Joe", 1) :: ("Anna", 100) :: ("Bob", 20) :: ("Joe", 2) :: Nil)
+// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[1] at makeRDD at <console>:24
+
+val totalPerUser =  allData.csumByKey
+// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[2] at reduceByKey at implicits.scala:18
+
+totalPerUser.collectAsMap
+// res7: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)
+
+

The same example would work for more complex keys.

+
val allDataComplexKeu =
+   sc.makeRDD( ("Bob", Map("task1" -> 10)) ::
+    ("Joe", Map("task1" -> 1, "task2" -> 3)) :: ("Bob", Map("task1" -> 10, "task2" -> 1)) :: ("Joe", Map("task3" -> 4)) :: Nil )
+// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ParallelCollectionRDD[3] at makeRDD at <console>:22
+
+val overalTasksPerUser = allDataComplexKeu.csumByKey
+// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ShuffledRDD[4] at reduceByKey at implicits.scala:18
+
+overalTasksPerUser.collectAsMap
+// res8: scala.collection.Map[String,scala.collection.immutable.Map[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))
+
+

Joins

+
// Type aliases for meaningful types
+type TimeSeries = Map[Int,Int]
+// defined type alias TimeSeries
+
+type UserName = String
+// defined type alias UserName
+
+

Example: Using the implicit full-our-join operator

+
import frameless.cats.outer._
+// import frameless.cats.outer._
+
+val day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 2, 1 -> 4)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Sam", Map(0 -> 1)) :: Nil )
+// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[5] at makeRDD at <console>:26
+
+val day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 10, 1 -> 11)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Joe", Map(0 -> 1, 1 -> 2)) :: Nil )
+// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[6] at makeRDD at <console>:26
+
+val daysCombined = day1 |+| day2
+// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[10] at mapValues at implicits.scala:43
+
+daysCombined.collect()
+// res10: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))
+
+

Note how the user's timeseries from different days have been aggregated together. +The |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join +on the key and combine values using the default Semigroup for the value type.

+

In cats:

+
Map(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)
+// res11: Map[Int,Int] = Map(1 -> 6, 2 -> 2)
+
+ + +
+ +
+
+
+ +

results matching ""

+
    + +
    +
    + +

    No results matching ""

    + +
    +
    +
    + +
    +
    + +
    + + + + + + + + + + + + + + +
    + + +
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/book/FeatureOverview.html b/docs/book/FeatureOverview.html new file mode 100644 index 000000000..661bee470 --- /dev/null +++ b/docs/book/FeatureOverview.html @@ -0,0 +1,717 @@ + + + + + + + TypedDataset: Feature Overview · GitBook + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    +
    + + + + + + + + +
    + +
    + +
    + + + + + + + + +
    +
    + +
    +
    + +
    + +

    TypedDataset: Feature Overview

    +

    This tutorial introduces TypedDataset using a simple example. +The following imports are needed to make all code examples compile.

    +
    import org.apache.spark.{SparkConf, SparkContext}
+import org.apache.spark.sql.SparkSession
+import frameless.functions.aggregate._
+import frameless.TypedDataset
+
+val conf = new SparkConf().setMaster("local[*]").setAppName("frameless repl").set("spark.ui.enabled", "false")
+val spark = SparkSession.builder().config(conf).appName("REPL").getOrCreate()
+implicit val sqlContext = spark.sqlContext
+spark.sparkContext.setLogLevel("WARN")
+
+import spark.implicits._
+
    +

    Creating TypedDataset instances

    +

    We start by defining a case class:

    +
    case class Apartment(city: String, surface: Int, price: Double)
+
    +

    And few Apartment instances:

    +
    val apartments = Seq(
+  Apartment("Paris", 50, 300000.0),
+  Apartment("Paris", 100, 450000.0),
+  Apartment("Paris", 25, 250000.0),
+  Apartment("Lyon", 83, 200000.0),
+  Apartment("Lyon", 45, 133000.0),
+  Apartment("Nice", 74, 325000.0)
+)
+
    +

    We are now ready to instantiate a TypedDataset[Apartment]:

    +
    val aptTypedDs = TypedDataset.create(apartments)
+// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]
+
    +

    We can also create one from an existing Spark Dataset:

    +
    val aptDs = spark.createDataset(apartments)
+// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 1 more field]
+
+val aptTypedDs = TypedDataset.create(aptDs)
+// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]
+
    +

    Or use the Frameless syntax:

    +
    import frameless.syntax._
+// import frameless.syntax._
+
+val aptTypedDs2 = aptDs.typed
+// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]
+
    +

    Typesafe column referencing

    +

    This is how we select a particular column from a TypedDataset:

    +
    val cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))
+// cities: frameless.TypedDataset[String] = [_1: string]
+
    +

    This is completely type-safe, for instance suppose we misspell city as citi:

    +
    aptTypedDs.select(aptTypedDs('citi))
+// <console>:28: error: No column Symbol with shapeless.tag.Tagged[String("citi")] of type A in Apartment
+//        aptTypedDs.select(aptTypedDs('citi))
+//                                    ^
+
    +

    This gets raised at compile-time, whereas with the standard Dataset API the error appears at run-time (enjoy the stack trace):

    +
    aptDs.select('citi)
+// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [city, surface, price];;
+// 'Project ['citi]
+// +- LocalRelation [city#206, surface#207, price#208]
+// 
+//   at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:77)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:74)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)
+//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:69)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:307)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionUp$1(QueryPlan.scala:269)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:279)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2$1.apply(QueryPlan.scala:283)
+//   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)
+//   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)
+//   at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)
+//   at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)
+//   at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)
+//   at scala.collection.AbstractTraversable.map(Traversable.scala:104)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:283)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$8.apply(QueryPlan.scala:288)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:186)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:288)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:74)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:67)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:126)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:67)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:58)
+//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:49)
+//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:64)
+//   at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2603)
+//   at org.apache.spark.sql.Dataset.select(Dataset.scala:969)
+//   ... 458 elided
+
    +

    select() supports arbitrary column operations:

    +
    aptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()
+// +----+---+
+// |  _1| _2|
+// +----+---+
+// | 500| 52|
+// |1000|102|
+// | 250| 27|
+// | 830| 85|
+// | 450| 47|
+// | 740| 76|
+// +----+---+
+//
+
    +

    Note that unlike the standard Spark API where some operations are lazy and some are not, TypedDatasets have all operations to be lazy. +In the above example, show() is lazy. It requires to apply run() for the show job to materialize. +A more detailed explanation of Job is given here.

    +

    Next we compute the price by surface unit:

    +
    val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))
+// <console>:27: error: overloaded method value / with alternatives:
+//   (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] <and>
+//   (u: frameless.TypedColumn[Apartment,Double])(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double]
+//  cannot be applied to (frameless.TypedColumn[Apartment,Int])
+//        val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))
+//                                                                      ^
+
    +

    As the error suggests, we can't divide a TypedColumn of Double by Int. +For safety, in Frameless only math operations between same types is allowed. +There are two ways to proceed here:

    +

    (a) Explicitly cast Int to Double (manual)

    +
    val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])
+// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]
+
+priceBySurfaceUnit.collect().run()
+// res6: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)
+
    +

    (b) Perform the cast implicitly (automated)

    +
    import frameless.implicits.widen._
+// import frameless.implicits.widen._
+
+val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))
+// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]
+
+priceBySurfaceUnit.collect.run()
+// res7: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)
+
    +

    Looks like it worked, but that cast seems unsafe right? Actually it is safe. +Let's try to cast a TypedColumn of String to Double:

    +
    aptTypedDs('city).cast[Double]
+// <console>:31: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]
+//        aptTypedDs('city).cast[Double]
+//                              ^
+
    +

    The compile-time error tells us that to perform the cast, an evidence +(in the form of CatalystCast[String, Double]) must be available. +Since casting from String to Double is not allowed, this results +in a compilation error.

    +

    Check here +for the set of available CatalystCast.

    +

    TypeSafe TypedDataset casting and projections

    +

    With select() the resulting TypedDataset is of type TypedDataset[TupleN[...]] (with N in [1...10]). +For example, if we select three columns with types String, Int, and Boolean the result will have type +TypedDataset[(String, Int, Boolean)]. To select more than ten columns use the selectMany() method. +Select has better IDE support than the macro based selectMany, so prefer select() for the general case.

    +

    We often want to give more expressive types to the result of our computations. +as[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long +as the types in U and T align.

    +

    When the cast is valid the expression compiles:

    +
    case class UpdatedSurface(city: String, surface: Int)
+// defined class UpdatedSurface
+
+val updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]
+// updated: frameless.TypedDataset[UpdatedSurface] = [city: string, surface: int]
+
+updated.show(2).run()
+// +-----+-------+
+// | city|surface|
+// +-----+-------+
+// |Paris|     52|
+// |Paris|    102|
+// +-----+-------+
+// only showing top 2 rows
+//
+
    +

    Next we try to cast a (String, String) to an UpdatedSurface (which has types String, Int). +The cast is not valid and the expression does not compile:

    +
    aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]
+// <console>:33: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]
+//        aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]
+//                                                                  ^
+
    +

    Projections

    +

    We often want to work with a subset of the fields in a dataset. +Projections allows to easily select the fields we are interested +while preserving their initial name and types for extra safety.

    +

    Here is an example using the TypedDataset[Apartment] with an additional column:

    +
    import frameless.implicits.widen._
+// import frameless.implicits.widen._
+
+val aptds = aptTypedDs // For shorter expressions
+// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]
+
+case class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)
+// defined class ApartmentDetails
+
+val aptWithRatio = aptds.select(aptds('city), aptds('price), aptds('surface), aptds('price) / aptds('surface)).as[ApartmentDetails]
+// aptWithRatio: frameless.TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]
+
    +

    Suppose we only want to work with city and ratio:

    +
    case class CityInfo(city: String, ratio: Double)
+// defined class CityInfo
+
+val cityRatio = aptWithRatio.project[CityInfo]
+// cityRatio: frameless.TypedDataset[CityInfo] = [city: string, ratio: double]
+
+cityRatio.show(2).run()
+// +-----+------+
+// | city| ratio|
+// +-----+------+
+// |Paris|6000.0|
+// |Paris|4500.0|
+// +-----+------+
+// only showing top 2 rows
+//
+
    +

    Suppose we only want to work with price and ratio:

    +
    case class PriceInfo(ratio: Double, price: Double)
+// defined class PriceInfo
+
+val priceInfo = aptWithRatio.project[PriceInfo]
+// priceInfo: frameless.TypedDataset[PriceInfo] = [ratio: double, price: double]
+
+priceInfo.show(2).run()
+// +------+--------+
+// | ratio|   price|
+// +------+--------+
+// |6000.0|300000.0|
+// |4500.0|450000.0|
+// +------+--------+
+// only showing top 2 rows
+//
+
    +

    We see that the order of the fields does not matter as long as the +names and the corresponding types agree. However, if we make a mistake in +any of the names and/or their types, then we get a compilation error.

    +

    Say we make a typo in a field name:

    +
    case class PriceInfo2(ratio: Double, pricEE: Double)
+
    +
    aptWithRatio.project[PriceInfo2]
+// <console>:36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?
+//        aptWithRatio.project[PriceInfo2]
+//                            ^
+
    +

    Say we make a mistake in the corresponding type:

    +
    case class PriceInfo3(ratio: Int, price: Double) // ratio should be Double
+
    +
    aptWithRatio.project[PriceInfo3]
+// <console>:36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?
+//        aptWithRatio.project[PriceInfo3]
+//                            ^
+
    +

    User Defined Functions

    +

    Frameless supports lifting any Scala function (up to five arguments) to the +context of a particular TypedDataset:

    +
    // The function we want to use as UDF
+val priceModifier =
+    (name: String, price:Double) => if(name == "Paris") price * 2.0 else price
+// priceModifier: (String, Double) => Double = <function2>
+
+val udf = aptTypedDs.makeUDF(priceModifier)
+// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = <function2>
+
+val aptds = aptTypedDs // For shorter expressions
+// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]
+
+val adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))
+// adjustedPrice: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]
+
+adjustedPrice.show().run()
+// +-----+--------+
+// |   _1|      _2|
+// +-----+--------+
+// |Paris|600000.0|
+// |Paris|900000.0|
+// |Paris|500000.0|
+// | Lyon|200000.0|
+// | Lyon|133000.0|
+// | Nice|325000.0|
+// +-----+--------+
+//
+
    +

    GroupBy and Aggregations

    +

    Let's suppose we wanted to retrieve the average apartment price in each city

    +
    val priceByCity = aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('price)))
+// priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]
+
+priceByCity.collect().run()
+// res17: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))
+
    +

    Again if we try to aggregate a column that can't be aggregated, we get a compilation error

    +
    aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                         ^
+// <console>:34: error: could not find implicit value for parameter averageable: frameless.CatalystAverageable[String,Out]
+//        aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                         ^
+//                                                     ^
+// <console>:34: warning: postfix operator ^ should be enabled
+// by making the implicit value scala.language.postfixOps visible.
+// This can be achieved by adding the import clause 'import scala.language.postfixOps'
+// or by setting the compiler option -language:postfixOps.
+// See the Scaladoc for value scala.language.postfixOps for a discussion
+// why the feature should be explicitly enabled.
+//        aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                         ^
+//                                                                                                                                  ^
+
    +

    Next, we combine select and groupBy to calculate the average price/surface ratio per city:

    +
    val aptds = aptTypedDs // For shorter expressions
+// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]
+
+val cityPriceRatio =  aptds.select(aptds('city), aptds('price) / aptds('surface))
+// cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]
+
+cityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()
+// +-----+------------------+
+// |   _1|                _2|
+// +-----+------------------+
+// | Nice| 4391.891891891892|
+// |Paris| 6833.333333333333|
+// | Lyon|2682.5970548862115|
+// +-----+------------------+
+//
+
    +

    Entire TypedDataset Aggregation

    +

    We often want to aggregate the entire TypedDataset and skip the groupBy() clause. +In Frameless you can do this using the agg() operator directly on the TypedDataset. +In the following example, we compute the average price, the average surface,
    the minimum surface, and the set of cities for the entire dataset.

    +
    case class Stats(
+   avgPrice: Double, 
+   avgSurface: Double, 
+   minSurface: Int, 
+   allCities: Vector[String])
+// defined class Stats
+
+aptds.agg(
+   avg(aptds('price)), 
+   avg(aptds('surface)),
+   min(aptds('surface)),
+   collectSet(aptds('city))
+).as[Stats].show().run() 
+// +-----------------+------------------+----------+-------------------+
+// |         avgPrice|        avgSurface|minSurface|          allCities|
+// +-----------------+------------------+----------+-------------------+
+// |276333.3333333333|62.833333333333336|        25|[Paris, Nice, Lyon]|
+// +-----------------+------------------+----------+-------------------+
+//
+
    +

    Joins

    +
    case class CityPopulationInfo(name: String, population: Int)
+
+val cityInfo = Seq(
+  CityPopulationInfo("Paris", 2229621),
+  CityPopulationInfo("Lyon", 500715),
+  CityPopulationInfo("Nice", 343629)
+)
+
+val citiInfoTypedDS = TypedDataset.create(cityInfo)
+
    +

    Here is how to join the population information to the apartment's dataset.

    +
    val withCityInfo = aptTypedDs.join(citiInfoTypedDS, aptTypedDs('city), citiInfoTypedDS('name))
+// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct<city: string, surface: int ... 1 more field>, _2: struct<name: string, population: int>]
+
+withCityInfo.show().run()
+// +--------------------+---------------+
+// |                  _1|             _2|
+// +--------------------+---------------+
+// | [Paris,50,300000.0]|[Paris,2229621]|
+// |[Paris,100,450000.0]|[Paris,2229621]|
+// | [Paris,25,250000.0]|[Paris,2229621]|
+// |  [Lyon,83,200000.0]|  [Lyon,500715]|
+// |  [Lyon,45,133000.0]|  [Lyon,500715]|
+// |  [Nice,74,325000.0]|  [Nice,343629]|
+// +--------------------+---------------+
+//
+
    +

    The joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].

    +

    We can then select which information we want to continue to work with:

    +
    case class AptPriceCity(city: String, aptPrice: Double, cityPopulation: Int)
+// defined class AptPriceCity
+
+withCityInfo.select(
+   withCityInfo.colMany('_2, 'name), withCityInfo.colMany('_1, 'price), withCityInfo.colMany('_2, 'population)
+).as[AptPriceCity].show().run
+// +-----+--------+--------------+
+// | city|aptPrice|cityPopulation|
+// +-----+--------+--------------+
+// |Paris|300000.0|       2229621|
+// |Paris|450000.0|       2229621|
+// |Paris|250000.0|       2229621|
+// | Lyon|200000.0|        500715|
+// | Lyon|133000.0|        500715|
+// | Nice|325000.0|        343629|
+// +-----+--------+--------------+
+//
+
    + + +
    + +
    +
    +
    + +

    results matching ""

    +
      + +
      +
      + +

      No results matching ""

      + +
      +
      +
      + +
      +
      + +
      + + + + + + + + + + + + + + +
      + + +
      + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/book/Injection.html b/docs/book/Injection.html new file mode 100644 index 000000000..428910d88 --- /dev/null +++ b/docs/book/Injection.html @@ -0,0 +1,409 @@ + + + + + + + Injection: Creating Custom Encoders · GitBook + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
      +
      + + + + + + + + +
      + +
      + +
      + + + + + + + + +
      +
      + +
      +
      + +
      + +

      Injection: Creating Custom Encoders

      +

      Injection lets us define encoders for types that do not have one by injecting A into an encodable type B. +This is the definition of the injection typeclass:

      +
      trait Injection[A, B] extends Serializable {
+  def apply(a: A): B
+  def invert(b: B): A
+}
+
      +

      Example

      +

      Let's define a simple case class:

      +
      case class Person(age: Int, birthday: java.util.Date)
+// defined class Person
+
+val people = Seq(Person(42, new java.util.Date))
+// people: Seq[Person] = List(Person(42,Mon May 22 09:53:10 CEST 2017))
+
      +

      And an instance of a TypedDataset:

      +
      val personDS = TypedDataset.create(people)
+// <console>:24: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]
+//        val personDS = TypedDataset.create(people)
+//                                          ^
+
      +

      Looks like we can't, a TypedEncoder instance of Person is not available, or more precisely for java.util.Date. +But we can define a injection from java.util.Date to an encodable type, like Long:

      +
      import frameless._
+// import frameless._
+
+implicit val dateToLongInjection = new Injection[java.util.Date, Long] {
+  def apply(d: java.util.Date): Long = d.getTime()
+  def invert(l: Long): java.util.Date = new java.util.Date(l)
+}
+// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@6cd5eaec
+
      +

      We can be less verbose using the Injection.apply function:

      +
      import frameless._
+// import frameless._
+
+implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
+// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@7a09999d
+
      +

      Now we can create our TypedDataset:

      +
      val personDS = TypedDataset.create(people)
+// personDS: frameless.TypedDataset[Person] = [age: int, birthday: bigint]
+
      +

      Another example

      +

      Let's define a sealed family:

      +
      sealed trait Gender
+// defined trait Gender
+
+case object Male extends Gender
+// defined object Male
+
+case object Female extends Gender
+// defined object Female
+
+case object Other extends Gender
+// defined object Other
+
      +

      And a simple case class:

      +
      case class Person(age: Int, gender: Gender)
+// defined class Person
+
+val people = Seq(Person(42, Male))
+// people: Seq[Person] = List(Person(42,Male))
+
      +

      Again if we try to create a TypedDataset, we get a compilation error.

      +
      val personDS = TypedDataset.create(people)
+// <console>:32: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]
+//        val personDS = TypedDataset.create(people)
+//                                          ^
+
      +

      Let's define an injection instance for Gender:

      +
      implicit val genderToInt: Injection[Gender, Int] = Injection(
+  {
+    case Male   => 1
+    case Female => 2
+    case Other  => 3
+  },
+  {
+    case 1 => Male
+    case 2 => Female
+    case 3 => Other
+  })
+// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@2ac4b462
+
      +

      And now we can create our TypedDataset:

      +
      val personDS = TypedDataset.create(people)
+// personDS: frameless.TypedDataset[Person] = [age: int, gender: int]
+
      + + +
      + +
      +
      +
      + +

      results matching ""

      +
        + +
        +
        + +

        No results matching ""

        + +
        +
        +
        + +
        +
        + +
        + + + + + + + + + + + + + + +
        + + +
        + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/book/Job.html b/docs/book/Job.html new file mode 100644 index 000000000..54e353fec --- /dev/null +++ b/docs/book/Job.html @@ -0,0 +1,369 @@ + + + + + + + Job[A] · GitBook + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
        +
        + + + + + + + + +
        + +
        + +
        + + + + + + + + +
        +
        + +
        +
        + +
        + +

        Job[A]

        +

        All operations on TypedDataset are lazy. An operation either returns a new +transformed TypedDataset or a Job[A], where A is the result of running a +non-lazy computation in Spark. Job serves several functions:

        +
          +
        • Makes all operations on a TypedDataset lazy, which makes them more predictable compared to having +few operations being lazy and other being strict
          • +
        • Allows the programmer to make expensive blocking operations explicit
          • +
        • Allows for Spark jobs to be lazily sequenced using monadic composition via for-comprehension
          • +
        • Provides an obvious place where you can annotate/name your Spark jobs to make it easier +to track different parts of your application in the Spark UI
          • +
        +

        The toy example showcases the use of for-comprehension to explicitly sequences Spark Jobs. +First we calculate the size of the TypedDataset and then we collect to the driver +exactly 20% of its elements:

        +
        val ds = TypedDataset.create(1 to 20)
+// ds: frameless.TypedDataset[Int] = [_1: int]
+
+val countAndTakeJob =
+  for {
+    count <- ds.count()
+    sample <- ds.take((count/5).toInt)
+  } yield sample
+// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@58cb898
+
+countAndTakeJob.run()
+// res1: Seq[Int] = WrappedArray(1, 2, 3, 4)
+
        +

        The countAndTakeJob can either be executed using run() (as we show above) or it can +be passed along to other parts of the program to be further composed into more complex sequences +of Spark jobs.

        +
        import frameless.Job
+// import frameless.Job
+
+def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min)
+// computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]
+
+val finalJob = computeMinOfSample(countAndTakeJob)
+// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@7b8ecc47
+
        +

        Now we can execute this new job by specifying a group-id and a description. +This allows the programmer to see this information on the Spark UI and help track, say, +performance issues.

        +
        finalJob.
+  withGroupId("samplingJob").
+  withDescription("Samples 20% of elements and computes the min").
+  run()
+// res2: Int = 1
+
        + + +
        + +
        +
        +
        + +

        results matching ""

        +
          + +
          +
          + +

          No results matching ""

          + +
          +
          +
          + +
          +
          + +
          + + + + + + + + + + + + + + +
          + + +
          + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/book/TypedDataFrame.html b/docs/book/TypedDataFrame.html new file mode 100644 index 000000000..f3f5762ed --- /dev/null +++ b/docs/book/TypedDataFrame.html @@ -0,0 +1,417 @@ + + + + + + + Proof of Concept: TypedDataFrame · GitBook + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
          +
          + + + + + + + + +
          + +
          + +
          + + + + + + + + +
          +
          + +
          +
          + +
          + +

          Proof of Concept: TypedDataFrame

          +

          TypedDataFrame is the API developed in the early stages of frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future developments of frameless. However, the design is interesting enough for being documented.

          +

          To safely manipulate DataFrames we use a technique called shadow type, which consists in storing additional information about a value in a "dummy" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.

          +

          Diving in

          +

          In TypedDataFrame, we use a single Schema <: Product to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:

          +
          import org.apache.spark.sql.DataFrame
+import shapeless.HList
+
+class TDataFrame[Schema <: Product](df: DataFrame) {
+  def filter(predicate: Schema => Boolean): TDataFrame[Schema] = ???
+
+  def select[C <: HList, Out <: Product](columns: C): TDataFrame[Out] = ???
+
+  def innerJoin[OtherS <: Product, Out <: Product]
+    (other: TDataFrame[OtherS]): TDataFrame[Out] = ???
+
+  // Followed by equivalent of every DataFrame method with improved signature
+}
+
          +

          As you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.

          +

          Type-level column referencing

          +

          For Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching column referencing at compile type. When everything goes well, frameless select is very similar to vanilla select, except that it keeps track of the selected column types:

          +
          import frameless.TypedDataFrame
+
+case class Foo(s: String, d: Double, i: Int)
+
+def selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =
+  tf.select('i, 's)
+
          +

          However, in case of typo, it gets coughs right away:

          +
          def selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =
+  tf.select('j, 's)
+
          +

          Type-level joins

          +

          Joins can available with two different syntaxes, the first lets you reference different columns on each TypedDataFrame, and ensures that their all exists and have compatible types:

          +
          case class Bar(i: Int, j: String, b: Boolean)
+
+def join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])
+    : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =
+  tf1.innerJoin(tf2).on('s).and('j)
+
          +

          The second syntax bring some convenience when the joining columns have identical names in both tables:

          +
          def join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])
+    : TypedDataFrame[(String, Double, Int, String, Boolean)] =
+  tf1.innerJoin(tf2).using('i)
+
          +

          Further example are available in the TypedDataFrame join tests.

          +

          Complete example

          +

          We now consider a complete example to see how the type system can frameless can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city map and neighborhood:

          +
          type Neighborhood = String
+type Address = String
+
+case class PhoneBookEntry(
+  address: Address,
+  residents: String,
+  phoneNumber: Double
+)
+
+case class CityMapEntry(
+  address: Address,
+  neighborhood: Neighborhood
+)
+
          +

          Our goal will be to compute the neighborhood with unique names, approximating "unique" with names containing less common +letters in the alphabet: 'x', 'q', and 'z'. We are going to need a natural language processing library at some point, so +let's use the following for the example:

          +
          object NLPLib {
+  def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))
+}
+
          +

          Suppose we manage to obtain a TypedDataFrame[PhoneBookEntry] and a TypedDataFrame[CityMapEntry] public data, here is what our Spark job could look like with frameless:

          +
          import org.apache.spark.sql.SQLContext
+
+// These case classes are used to hold intermediate results
+case class Family(residents: String, neighborhood: Neighborhood)
+case class Person(name: String, neighborhood: Neighborhood)
+case class NeighborhoodCount(neighborhood: Neighborhood, count: Long)
+
+def bestNeighborhood
+  (phoneBookTF: TypedDataFrame[PhoneBookEntry], cityMapTF: TypedDataFrame[CityMapEntry])
+  (implicit c: SQLContext): String = {
+                                          (((((((((
+  phoneBookTF
+    .innerJoin(cityMapTF).using('address) :TypedDataFrame[(Address, String, Double, String)])
+    .select('_2, '_4)                     :TypedDataFrame[(String, String)])
+    .as[Family]()                         :TypedDataFrame[Family])
+    .flatMap { f =>
+      f.residents.split(' ').map(r => Person(r, f.neighborhood))
+    }                                     :TypedDataFrame[Person])
+    .filter { p =>
+      NLPLib.uniqueName(p.name)
+    }                                     :TypedDataFrame[Person])
+    .groupBy('neighborhood).count()       :TypedDataFrame[(String, Long)])
+    .as[NeighborhoodCount]()              :TypedDataFrame[NeighborhoodCount])
+    .sortDesc('count)                     :TypedDataFrame[NeighborhoodCount])
+    .select('neighborhood)                :TypedDataFrame[Tuple1[String]])
+    .head._1
+}
+
          +

          If you compare this version from Spark vanilla where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.

          +

          Limitations

          +

          The main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.

          +

          In the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.

          + + +
          + +
          +
          +
          + +

          results matching ""

          +
            + +
            +
            + +

            No results matching ""

            + +
            +
            +
            + +
            +
            + +
            + + + + + + + + + + +
            + + +
            + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/book/TypedDatasetVsSparkDataset.html b/docs/book/TypedDatasetVsSparkDataset.html new file mode 100644 index 000000000..1ae81e091 --- /dev/null +++ b/docs/book/TypedDatasetVsSparkDataset.html @@ -0,0 +1,532 @@ + + + + + + + Comparing TypedDatasets with Spark's Datasets · GitBook + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
            +
            + + + + + + + + +
            + +
            + +
            + + + + + + + + +
            +
            + +
            +
            + +
            + +

            Comparing TypedDatasets with Spark's Datasets

            +

            Goal: + This tutorial compares the standard Spark Datasets api with the one provided by + frameless' TypedDataset. It shows how TypedDatsets allows for an expressive and + type-safe api with no compromises on performance.

            +

            For this tutorial we first create a simple dataset and save it on disk as a parquet file. +Parquet is a popular columnar format and well supported by Spark. +It's important to note that when operating on parquet datasets, Spark knows that each column is stored +separately, so if we only need a subset of the columns Spark will optimize for this and avoid reading +the entire dataset. This is a rather simplistic view of how Spark and parquet work together but it +will serve us well for the context of this discussion.

            +
            import spark.implicits._
+// import spark.implicits._
+
+// Our example case class Foo acting here as a schema
+case class Foo(i: Long, j: String)
+// defined class Foo
+
+// Assuming spark is loaded and SparkSession is bind to spark
+val initialDs = spark.createDataset( Foo(1, "Q") :: Foo(10, "W") :: Foo(100, "E") :: Nil )
+// initialDs: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]
+
+// Assuming you are on Linux or Mac OS
+initialDs.write.parquet("/tmp/foo")
+
+val ds = spark.read.parquet("/tmp/foo").as[Foo]
+// ds: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]
+
+ds.show()
+// +---+---+
+// |  i|  j|
+// +---+---+
+// | 10|  W|
+// |100|  E|
+// |  1|  Q|
+// +---+---+
+//
+
            +

            The value ds holds the content of the initialDs read from a parquet file. +Let's try to only use field i from Foo and see how Spark's Catalyst (the query optimizer) +optimizes this.

            +
            // Using a standard Spark TypedColumn in select()
+val filteredDs = ds.filter($"i" === 10).select($"i".as[Long])
+// filteredDs: org.apache.spark.sql.Dataset[Long] = [i: bigint]
+
+filteredDs.show()
+// +---+
+// |  i|
+// +---+
+// | 10|
+// +---+
+//
+
            +

            The filteredDs is of type Dataset[Long]. Since we only access field i from Foo the type is correct. +Unfortunately, this syntax requires handholding by explicitly setting the TypedColumn in the select statement +to return type Long (look at the as[Long] statement). We will discuss this limitation next in more detail. +Now, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.

            +
            filteredDs.explain()
+// == Physical Plan ==
+// *Project [i#69L]
+// +- *Filter (isnotnull(i#69L) && (i#69L = 10))
+//    +- *BatchedScan parquet [i#69L] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct<i:bigint>
+
            +

            The last line is very important (see ReadSchema). The schema read +from the parquet file only required reading column i without needing to access column j. +This is great! We have both an optimized query plan and type-safety!

            +

            Unfortunately, this syntax is not bulletproof: it fails at run-time if we try to access +a non existing column x:

            +
            scala> ds.filter($"i" === 10).select($"x".as[Long])
+org.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];;
+'Project ['x]
++- Filter (i#69L = cast(10 as bigint))
+   +- Relation[i#69L,j#70] parquet
+
+  at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)
+  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:77)
+  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:74)
+  at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)
+  at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)
+  at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:69)
+  at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:307)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionUp$1(QueryPlan.scala:269)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:279)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2$1.apply(QueryPlan.scala:283)
+  at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)
+  at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)
+  at scala.collection.immutable.List.foreach(List.scala:392)
+  at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)
+  at scala.collection.immutable.List.map(List.scala:296)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:283)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$8.apply(QueryPlan.scala:288)
+  at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:186)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:288)
+  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:74)
+  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:67)
+  at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:126)
+  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:67)
+  at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:58)
+  at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:49)
+  at org.apache.spark.sql.Dataset.<init>(Dataset.scala:161)
+  at org.apache.spark.sql.Dataset.<init>(Dataset.scala:167)
+  at org.apache.spark.sql.Dataset.select(Dataset.scala:1023)
+  ... 450 elided
+
            +

            There are two things to improve here. First, we would want to avoid the at[Long] casting that we are required +to type for type-safety. This is clearly an area where we can introduce a bug by casting to an incompatible +type. Second, we want a solution where reference to a +non existing column name fails at compilation time. +The standard Spark Dataset can achieve this using the following syntax.

            +
            ds.filter(_.i == 10).map(_.i).show()
+// +-----+
+// |value|
+// +-----+
+// |   10|
+// +-----+
+//
+
            +

            This looks great! It reminds us the familiar syntax from Scala. +The two closures in filter and map are functions that operate on Foo and the +compiler will helps us capture all the mistakes we mentioned above.

            +
            scala> ds.filter(_.i == 10).map(_.x).show()
+<console>:20: error: value x is not a member of Foo
+       ds.filter(_.i == 10).map(_.x).show()
+                                  ^
+
            +

            Unfortunately, this syntax does not allow Spark to optimize the code.

            +
            ds.filter(_.i == 10).map(_.i).explain()
+// == Physical Plan ==
+// *SerializeFromObject [input[0, bigint, true] AS value#105L]
+// +- *MapElements <function1>, obj#104: bigint
+//    +- *DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#103: $line14.$read$$iw$$iw$$iw$$iw$Foo
+//       +- *Filter <function1>.apply
+//          +- *BatchedScan parquet [i#69L,j#70] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [], ReadSchema: struct<i:bigint,j:string>
+
            +

            As we see from the explained Physical Plan, Spark was not able to optimize our query as before. +Reading the parquet file will required loading all the fields of Foo. This might be ok for +small datasets or for datasets with few columns, but will be extremely slow for most practical +applications. +Intuitively, Spark currently doesn't have a way to look inside the code we pass in these two +closures. It only knows that they both take one argument of type Foo, but it has no way of knowing if +we use just one or all of Foo's fields.

            +

            The TypedDataset in frameless solves this problem. It allows for a simple and type-safe syntax +with a fully optimized query plan.

            +
            import frameless.TypedDataset
+// import frameless.TypedDataset
+
+val fds = TypedDataset.create(ds)
+// fds: frameless.TypedDataset[Foo] = [i: bigint, j: string]
+
+fds.filter( fds('i) === 10 ).select( fds('i) ).show().run()
+// +---+
+// | _1|
+// +---+
+// | 10|
+// +---+
+//
+
            +

            And the optimized Physical Plan:

            +
            fds.filter( fds('i) === 10 ).select( fds('i) ).explain()
+// == Physical Plan ==
+// *Project [i#69L AS _1#176L]
+// +- *Filter (isnotnull(i#69L) && (i#69L = 10))
+//    +- *BatchedScan parquet [i#69L] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct<i:bigint>
+
            +

            And the compiler is our friend.

            +
            scala> fds.filter( fds('i) === 10 ).select( fds('x) )
+<console>:21: error: No column Symbol with shapeless.tag.Tagged[String("x")] of type A in Foo
+       fds.filter( fds('i) === 10 ).select( fds('x) )
+                                               ^
+
            +

            Differences in Encoders

            +

            Encoders in Spark's Datasets are partially type-safe. If you try to create a Dataset using a type that is not + a Scala Product then you get a compilation error:

            +
            class Bar(i: Int)
+// defined class Bar
+
            +

            Bar is neither a case class nor a Product, so the following correctly gives a compilation error in Spark:

            +
            scala> spark.createDataset(Seq(new Bar(1)))
+<console>:21: error: Unable to find encoder for type stored in a Dataset.  Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._  Support for serializing other types will be added in future releases.
+       spark.createDataset(Seq(new Bar(1)))
+                          ^
+
            +

            However, the compile type guards implemented in Spark are not sufficient to detect non encodable members. +For example, using the following case class leads to a runtime failure:

            +
            case class MyDate(jday: java.util.Date)
+// defined class MyDate
+
            +
            val myDateDs = spark.createDataset(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))
+// java.lang.UnsupportedOperationException: No Encoder found for java.util.Date
+// - field (class: "java.util.Date", name: "jday")
+// - root class: "MyDate"
+//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:598)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:592)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:583)
+//   at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)
+//   at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)
+//   at scala.collection.immutable.List.foreach(List.scala:392)
+//   at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)
+//   at scala.collection.immutable.List.flatMap(List.scala:355)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:583)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:425)
+//   at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:61)
+//   at org.apache.spark.sql.Encoders$.product(Encoders.scala:274)
+//   at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:47)
+//   ... 770 elided
+
            +

            In comparison, a TypedDataset will notify about the encoding problem at compile time:

            +
            TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))
+// <console>:22: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[MyDate]
+//        TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))
+//                           ^
+
            + + +
            + +
            +
            +
            + +

            results matching ""

            +
              + +
              +
              + +

              No results matching ""

              + +
              +
              +
              + +
              +
              + +
              + + + + + + + + + + + + + + +
              + + +
              + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/book/TypedEncoder.html b/docs/book/TypedEncoder.html new file mode 100644 index 000000000..e18711db8 --- /dev/null +++ b/docs/book/TypedEncoder.html @@ -0,0 +1,378 @@ + + + + + + + Typed Encoders in Frameless · GitBook + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
              +
              + + + + + + + + +
              + +
              + +
              + + + + + + + + +
              +
              + +
              +
              + +
              + +

              Typed Encoders in Frameless

              +

              Spark uses Reflection to derive it's Encoders, which is why they can fail at run time. For example, because Spark does not supports java.util.Date, the following leads to an error:

              +
              import org.apache.spark.sql.Dataset
+import spark.implicits._
+
+case class DateRange(s: java.util.Date, e: java.util.Date)
+
              +
              scala> val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))
+java.lang.UnsupportedOperationException: No Encoder found for java.util.Date
+- field (class: "java.util.Date", name: "s")
+- root class: "DateRange"
+  at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:598)
+  at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:592)
+  at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:583)
+  at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)
+  at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)
+  at scala.collection.immutable.List.foreach(List.scala:392)
+  at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)
+  at scala.collection.immutable.List.flatMap(List.scala:355)
+  at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:583)
+  at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:425)
+  at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:61)
+  at org.apache.spark.sql.Encoders$.product(Encoders.scala:274)
+  at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:47)
+  ... 230 elided
+
              +

              As shown by the stack trace, this runtime error goes thought ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection based approach is it's inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.

              +

              Frameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the code java.util.Date example won't compile with frameless:

              +
              import frameless.TypedDataset
+
              +
              val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))
+// <console>:26: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]
+//        val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))
+//                                                             ^
+
              +

              Type class derivation takes case or recursively constructing (and proving the existence) TypeEncoders for case classes. The following works as expected:

              +
              case class Bar(d: Double, s: String)
+// defined class Bar
+
+case class Foo(i: Int, b: Bar)
+// defined class Foo
+
+val ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s"))))
+// ds: frameless.TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>]
+
+ds.collect()
+// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@4e32dea0
+
              +

              But any non-encodable in the case class hierarchy will be detected at compile time:

              +
              case class BarDate(d: Double, s: String, t: java.util.Date)
+case class FooDate(i: Int, b: BarDate)
+
              +
              val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, "s", new java.util.Date))))
+// <console>:28: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]
+//        val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, "s", new java.util.Date))))
+//                                                           ^
+
              +

              It should be noted that once derived, reflection based Encoders and implicitly derived TypeEncoders have identical performances. The derivation mechanism is different, but the objects generated to encode and decode JVM object in the Spark internal representation behave the same at run-time.

              + + +
              + +
              +
              +
              + +

              results matching ""

              +
                + +
                +
                + +

                No results matching ""

                + +
                +
                +
                + +
                +
                + +
                + + + + + + + + + + + + + + +
                + + +
                + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/book/gitbook/fonts/fontawesome/FontAwesome.otf b/docs/book/gitbook/fonts/fontawesome/FontAwesome.otf new file mode 100644 index 0000000000000000000000000000000000000000..d4de13e832d567ff29c5b4e9561b8c370348cc9c GIT binary patch literal 124988 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ÐT?>-5aYhU|+1c>&YMpPK5x#-mbV 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'NS^o{z1ZKlHsAybrl=JE7AP369ntV%vB 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 CDx5C> literal 0 HcmV?d00001 diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.eot b/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.eot new file mode 100644 index 0000000000000000000000000000000000000000..c7b00d2ba8896fd29de846b19f89fcf0d56ad152 GIT binary patch literal 76518 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%0DyT{kunD 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⋙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 z + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.ttf b/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.ttf new file mode 100644 index 0000000000000000000000000000000000000000..f221e50a2ef60738ba30932d834530cdfe55cb3e GIT binary patch literal 152796 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

                =v_rA!CPE#mM^4@)}X7qf;At+v)G*FZd&; zy?NqUnt;NNNMWLA%l4wI5KdaBwS^`}^ix}E_7m=0=&c|9@<&w5sD7Gn!)y#!FZz13 zdYig~JSHIF6!eE!qw7z+9FE7s>bNjpQ>bwUB5FPoa3Yl;m=gPn!2M(kM>~8Ojxe>H zW$4hf36N-<$w^=k{F*V8Q?q0?0p3j<%hL27f?Z%DtVj3hZy`&A;qoKu8Gcs7vlzSZ zP}jncpHdHjxY1ipKZk~nzd%EWfuZ5U&=G{7!wzIEcK(7$VB~Pq5#cY`tV8ve;N-OW z={2NEB?+l%@uHpajTR`bM9*Co)fG&=q zHdxS+Ob(l3Ic=!i;(zv8zkh|lDnf}!6_Tf4VRw!i5%$;z6)#r6j+}LD!otRjS_?89 zWTj{;@BxwIu$3D&tW*`>O3b^l{BbemMQ?mjFf#i9 zOtrpwquM|^#}Y1^D9r-J49Fp%Dfyr=NNvF!XdnyG8q+8Qdosk?r4rbGq2)-FwUW#~ z^TNcDtb(sOu>3DMcX)^H@K`hPy7qDN8^%q&LX>EZ$Lc25Rz;`ar|kDWJVRF|aTJ`wLVvDBxc8Ijp+kP*ct(b@qs zi4k2MVVNkwOu1yt+SezH_|Ukr4)W6)-|zBqiAo}2~5p|W@mRFWyzf$m|bES^Ih%IB}5rF&KE zi7Ul&y7GzG=nL%nROJ5TTTh7lPrQ}9pB@->ftwiO3{MYL$Ho9roaOOieS{B(=ZkRH zB#eM?`Vj|m{DBPHR7n)M6E{|FpyO;dh;#SYBDS47aoA&{GfpG&FO^wco@P|azIWz_ zhAOH2AS1;QeJR>alamnePZ%ZySmE7V6*iRsD&R%aKc?vCt;UuYTs!-(`QD!M z2P^qs?tU6Jn%)9>I9^E)zl0!rv&)i3copSY{wzHs@TAAFM^U%6-Sp(mlBe8Kpw zaD=I06InH-FwL+_%YcrWFU61n^w!6*_W}0_xfi%_j?6((P?&)X$QIZ2Pon?L2S%8t+fFXHxv$B+quBNHRGe zFJQ^}8N8jP@OC^<*iujL%K*2|SF=(anNr7wNH25aFLo2iUYn1a$WQB6qAJl5RK@SD z@9aQVlRWbQZK1Z(TB3J8i+AQqzTc(61pHCAh6upo*y5$sOW3Mx!AMbprFz@pfy7cY ze)E$&k9(VGJW0kgKbbUsg|UXaDdr-DzT>Slt~t=0dGZq|@^TpybVn-`89(WvVpaq`1rMJyX#fe>-IQwhg-fa^CbV?0Jt(P!2{lpQbdk8YCF!` z(!Z{AhE{KN2fWq@cFO7lFW$xW5+#CC(dFrF;U)1X%^&%SWEbTa3yM-0s85(kycJu5R8^ZUVvDwr<%wy3Wjeu9I z$01-HS|LLKgb`C=uVM6cHRRz?&?h_$`bCDpZbK%|+0(9y^2K*?Nri!k;Gx93N^8)p z_hgnTR8WbiNz@BlRwfbeN&FLe@YTTi!Ue;Lp=PR@>9%tYG^A5OI)&At_9i=E0|FmE zRsDWTRU{j^yv2A=K)Uf>%jL*dwJ;l!<}GG37lEyK%Xp9d0Z&|w+aEVx65iHrAIBqC zA!@js){_10X}SO!)o&8&d@MQ092p{y z_?LW8p9BIp__)tzbG_!W*$@)s>n^`KnhrVn=jUDifb)50z|St@S2;9`MROGP+T7q; zA?e8We^pGZ&Fh zu((K)CYBqFTKkQBBASmTjIMvXHPVckS%KurFe8Cf5Iq9vN|t9ZHi1>XCYdro5Lzynrhr-^OWAIqCt-q0 z=4uN5pfu<3q=|gacB;^Rm6!P^4OMX->UHCU(3!8_xPHsqFa6~&d_qI?%eMrg z(ZKoJji1b@|AX-s3%yZ4qy7yRGXC@i$<0soqpbs=dn(~+HC;LnklzUlx^~#;_(r!g zN$oT#5|A1wX0|xqDm+R_#_tC&1oI=5Bfk@X7@SZ$L1^>lh0E8XFQ4W+hkL>9W>*-i zHjKCV9NRr(?mu=xAn0>`6X$2dl8Kd>}n*pRwgP^Il# zbXdibSNq0fd!Oi6y*b^X$ZpN}FQbrAoqbjpcUun++Bvf!t?_R&*-%_Ex940Q{_+0a zyxP~E?|q^$$M5RXnCxVOM&a9DSD%&J2M_BWr(=zkW#DBMw!kAe=Tsl>@6FOqMlq8x zmZ#f6lQlP4KrfQ6hukl2T5%^wogv*8*4^UzknpC6k8!V5zH`*QGJh~|g+uIKd?*FP zoP#sp0PBM*QQqhuo#q4LdXA1T6h}!Ijf;}Q4mBt0prJ987`nXRq(oICI$duc z>16uMW3OcHuUOCO0JxY=*o8{)6>m|nhZfmi!ZbwZBMVJnixKwW7VZwWobz)udt( z@`f(C`caWn(zu0_n<`>0)s54qEWc>m46}|=7fVkmwX2>zr*lqYwGfjGx}f&XL+zbs zOx9iDx|S*Fi@qZ6V?%`Nq`b9Mpl0&amhP*1R%}~*ep_5TJmQL39OH&{Mfw+@Ln2K< zkbp$jRN$~wI+N;1(H^LFQfP#3hD}q^rK85Bf1Ne|1>?l{Y2GSDR+$a{gZj8&V?~Yq z(P!^F%6h;0SN2J{#rTx*%gdcfPLnpuDLH8U!3vu(uUh2E2%SJ0HNk~qL6DIy z>C{NHO%c0<>_VUs_?LrMrgekZc5)P~KI!UIVE)0Z#jYznA4$1c7V*O14V#MOdDdg? z*Lluu?8$jEs?BpEq--p=+_c#T{* z%)}*@bL6e|;YW-bwW3xj_ zm>57aYKQzo5xnDv@rsjgJ1gY<1T=$EB<1l`@qhWD03pd!>2fGKQ~o8AY8R0{%y=Ji z-jFJi^7hF#&p0w;kJuY)$E$KD(oSD(Fr^n^1`{G|?Ey2R;TkGVic+^@)yeFt9XnPr z9C`n$9dds`;)`Q=`JCE%V{_Z=NKI`$+l@1u*njaH zW3#4sm9oZ=EJxybP1x4J+66#F+&~e6gesQ?+f>~0JOqnaTIFh5$`;kK%CFifSXi0X z7VA~$Yw-a70e7*iF3EY)@(KJ-C_4_&9ib@(teSELp%*@5g~M9kve$#uFE$Rf1E@~r zEQF_MPj`aC4bq&!K8AilD6GvCay*9-z)zL_E&&+L3^`A6{D-BnbTS8wcOoa}3aE_b zPUe&x%^_fy>K`X%QM0B)Wvhd60kIqgxk;xKq`)v32Zjb+Nhh!~-QZZ#9ixEzZhn$h%#u=L*j8r`Ig-zety>2{s<0hCp2)ia3b{+C# zmDYv@DQC}3%d7qR<~6Nd*G*xSeEt@fMVWdoTOqHWz4a3Zm-(#cFh2a$L5vUPqS$_@ zU|C7C=xyt)Csfgyp`KL3m9woBWur|QAhUsQzF70d*cscWUVqP1|NifVx9O6wz(AAu z(my_ga9cmJ_V4-Z9}Ay{%?VnFS7H3|E}`3`SVL9VInt2tcjFFmdS%>2M{(V=cqT4+ zQZdaFicwmQ15EUC_j$1-uPWvhllOHR|fY{{7)rUjO{o0I{D6Fng+j< zE!?c-=4VbwFwTMOGBcllDe7C@L-asHmqmno8T@vR!8i4FdRW2y=Wp1R%bgStsB{!_ zK1bV&IS-PbI9e}eoBCifNHoC|IF9VMb>S?6Nf%TM99zj@0+@_-mfSmQ6gdkMFn?py zVloAzv;1#sz1DPHv)uPubYW9Nw6NyT;iq1Dp0)Nr_0pZ}l0LbmF1FU|v}uc%T{uBL z1QW8wO^tp$EY61HT^p-wp@$oq7DoBwcfRygKWlydrKb)bG9K-do3Y7x*V?oN=dS2M z^Cc|$Q*PM19mNcJF)z1ChozIneo;IhvwvXyK(-dAiKI&)<0-}u`a-7aW0AvuBEPWD z6odQ#k%4XhXF~jl+ROkycn4~v`Z1EJG>`+mN5l;RhXA?))E#Yn6z?$<2Cjgc8O&u+ z9<72HP5de2#}7 zc6!?srMs(mqpeX>wkd61=fnSO`C=HOQ-TNw0K;|))Ho8x17ElKSw(&0xal^VL$BGY zukbsr99!YGecTqjP`7-f%4%~h42?-uFt2^6sNL$Y)ZC!2@VTyR8Bx^J8yZ&^=H9}< zZjZaF^4dy8p1nHAd2sb?SwXhS?ZJ)eFx`L;_(ixiyOGbLd*N!geDr_v6v3~+!Gab} z3b~Po0!X9@90_jVG67Cf5h4PLcZ-Fo*C^o{jo_A?meX2&j8<#{unMG1A%ebXeB)ow zUvcvziB{R}hZ~8^RT+i~2~TyC(ECLXzY z#reju?@g?Ef;DWu<*xAU`{a9#KfS%vb3ua@oF`m}G)0%Ov8IB_hKe~q*?RBWJ9id# zZu{|^iiTt`r7_%8G)S6J6}hsI(h{}=poQ9% z0}ES?{=RHqq$1fE>QqvdV-k&N#0qgHtH*}NsXx8*#=Kfn@5=<-vF6-(YYNoq=RTUa zsP7v$Z4Ma&gm9TJv2Nn{ig2nq-L~wmS>q0^-+zFrPVrpZf{8zvw03pmhL1FdXQ-{Q zOnt&v$Z5LU;^lKc9jWomofm7JSvkeaRwXW+7f&ph9t^EpaPJf6G&ju8@LXno#hvpr zl{fBaN>1Cg<)TaW11^ZJ1abqO)*&g{Gy+7|9DAwN^(h3@zvL;YnSKl{3(o{##Setv6v^_ zm>5%;QaVG8$%+WZll8SO%Op*&3TS*HaTY@7%fEYjNvZA?HifXJW1DjBxWuZiuX2JLv}# z7qni!|B{Ptm@#u&GQM`{`N7r&cft#iMy+AYn8$Xi3)Y2#(-$P-^8`Kcc{!^RKMp$S zw1C5Mc65MYb>PHzPY) zeXG`QTQ{e|*X^sAvu@k^RejT&zrknn8Q;tyfU@r_v6bb|ExCDai>GbD^k^s)oxY&W z(=zwwCC_}L@G>9!&1WdUvhPfxmy7MiW*7s>*dS$z#|lBbJUr8wVDm!JM0Fysk&DzT z>~Tr}VQR;C4&GO8M3ExGh$2cAvn2gsF`yu?W>e&Te_?=39Yu_ z%E`{{{Hw3F&zRBPHgo3Sr`dgvJho+BPhmIPk@D4#f0SQePH7U3mXsXUqMhvNp~oar z0_IE>JEP#Jf^X5(nJ`Dre*x)hPrVyk;NI>urR zUHqd@{jtz+KGnKTWq?97$(I@%W0HFl_rHa{>s z2hEp|VnUrsahQwz6Ui>Z;Aqp(qPI%7OAn%N9qAN>Lokn>9qD2|+<`p=*TZJMhTJy- zophyxwM#K67=Up;_Mfzilg0ua7P~P#&qd%Vn!irOjDtQDRBtz2M`zo<@kav)^xmE*IRU1u~=kfyrRHkREB4^&UK5f&DIrJ$4~Ki+-R{yVKaqW$Sa>V z{<~fFINF;bv$xhpCb^kvx9Cb$C>qtZu_3K8bIGhl6T9bWRUVJmtA}c|dEFBiO<0~u zc$C^~!&>g}$nDI|?=Htl(4h*sQyz%GZQ_AayuQ+TWUQ(hibT-S377*j7a!83QY5pY zMf=$z_kA{a$rL6{xg^LwD}whmk+CLOYMzoPs2R&6lpo92np?YhgoGYC)?&!)IdhJzlY$6_q7*h+@Y@D-07htO z0itlk9^mUl99_X;nPtU;K*B@=3YD-~R)AKG3>Z{zbJ-m>i_NB3{R;z=|2V1n^66bW zr}f=7zA{u1s#sGw;q?j6UVi(}w&r#Ze&XiuPxx&YuFYK+s!YtyoxkvrZ*QOc=0tyQ zV97iiR}?D(PVyJV+*?%>JtqRs|D=yu$Av3G9pmTz*Pm~1=x+=!A5$HwO`P*{7P$9m z;~OVC$5dBeGq>V`aKjUg*Zl0rSEo&yvT&Sj-LmkCu+8hWg|vo8X-pU$M0^8il7YL> zdkln0y+Lh>*acWa^nnTTupoM`24h3xLrDhjA2VzgC9%H3FqH_{gX>nWs%p#DF1D^+ zkTd?gXk5KqWB2K8U9FYNt6aLT-kyrNvkoA6NC$Do=S$$otlLM~mCZ%%1 zEdMM`W(`%#D_gtTbf3LOt{=CEd2Yqq*$XI|R2`7>T03}rrIU*7?cpoWTgRepWkVj)gRpRpO zOh%1{Y`%$I9^LN<$(P*U$(@?sIKI&qkmZU`UqIGOu&r>f3q$;cDRF%!WrY_YUu*yBkbFT@~FnJXrzN_uQsyc9S&6c)PgkP;Sz z6Qm%JKXz!#reDl@Kk=&Zlg}B)UaxO{{m>N$YU9!7rcHZiEbLi0=0>*i1PcK2P? zm%QR4W&PTjuIL>`;objp)q~0|e#;uw9{!gtN=hDc-_i@_Km27|Dsk80%YqZGpK23p z>*7;6`Cmah3HdkB287Zw0$5QHE83J><$rzj{K+htHjE>uq*E_{ey{phoRE-FxN)tR<}!cNcZ3#tZZO`0Ckp$$GWjxY4?QC2`1Jp zAQ8gY>41*NkQw|d0Ysfv1G$~}$x~r14~&&g!KKgVAKG@!jo93FOS`W)W9#i~*Xx3T z&el$B*`W?@8txds{$o{ywNF^NW?JK-C{CpT;$1I7dm%pMHk&Nlto6Fprs0>cS}j(quhrskSgcOR zG}!|l*FD{f?^8|W9*+_emOwu~Xr?gtLRvC=XqO~ue{dUP*D+y*kk8d zuU)x(>v?x9?x@fbklr*m#u^ma>T)6GLsvMQ8tX*ti_|*BSD`Lo51#xnTQhi@uF5L5 z--v3rYO39q(j876Mhh0Z!-}8Bt|}pz+c>%1$%A$-S73eshxjMxwInjw@<_l(gd|Nm zwh(g880L|L-=~&K!5k|E5t^{{F+W5A%3Q?Tk@F@01d7{}?`kNEc=&Y+$Ai}a=piT0 zVLx-j#)G89&3N~ycLfF1fsh4%0Lm7-aR}mSilG({Y6C={nV%VP`ZZY3IQ{SA*vF(C zL%pkehTUp$d0@clKM6$`??aF%Kflcpe3l1ak>k;VX^1*j8JNJIw$ zrtzsmces=ozUP3IgO8aG!F&_<`>OA*Oz@ELjW;S`trb!GS>oF3?&eN}C5hf2NixTm zV32#u&nxQ#zKF~;_Mgvv<5lJnUc$zAqk&+&@(ngK#1oZwSNpuqyRW;}c}5sg!eNK4>$N_{Em*WgwJ#$cG+!D?2<=&v(76I%QYqD(`naYz;kA z{5x6-whU7N_73~4)9ZB>ZZ-0PP0m)f^3|E1o=oA%RW%66w6;l&H4|H_n!>kFzG2z59jklL zRI;5IOvuj}KWQ|MLyrg8$wKaw2Y$2zey4#s2YnAj2J{kYV{yrgh)NKI1U-VuB)EcG zMJhu$&PNh$M3p4T91viQEI;6xbYAT8xrH0lfbrhA6(4`@<15A~d2}R;1!iPnwQ%kQ zQ__EW-U16d%kzIqPr2aSL$UKFc|3D3XXDry9%#FA?bNAjuWT#4ZM@RnORKK8y=m3n z&m6yZKU1Ur0MVETYHgg{fA8_n>|KTS!@x0o%tH$PN_-4jYTiy8FI9sDbuMOONceJU|HtxB` z>RLzUn+*5!SMA1zN6Mup@)WBxZKgur{)jfUi@#1ar*G<6jr3{bf^6~V!X&V)50O)9YtrZiQB zG_{bgNz`088}7BvhB>oqX3mbq<~;x1C5MYrR5l-w_^~SvDsdr6{m9`@O)82}W417? z8C?~8TD`NOZtT?5El-8m4duerz=X`w=IK-J9TUthSyDNnkjrMvg{ZxmEB1F!FeRun zCz+x^tKS=SN9B2)!E?K_^>=NbF&RQsp_>=u(+SK0+ovR?N`mI%H1Sw(*#3!XCPg*D zcbq7%Fjx%Qph2X-{)9FQ2zrXVlwdUwEtz;&a&sYqAuf)vOCVYt20JiJ=!?bbr%i6C z<`AvVX>e6Azb_QD%)SsKR>-$5L|Df8rgT+VvwYbL&$IP{YdSDLV+>6C)bqF9cZjhm za$Grh#mDxqXE%hNx+OJrY+Zx1ej2ZERRt@;HWtgw&+%MEYg1g7HNGSp0(THkg{Mq! zUYeN@SO8n#A@OQO?7VZcS(7iLxS5&xlV*Nmx7vGIC^(^e{}q?-pFCsxUG>@SbAz4p zWDKI$Z-tRYQT{As^#Zn((ntUw=#b3mV9Yd~kT2n0jH(z*S}gP*L=~CuKtM`jsM0Rm zq87OqkXhso3b?8U0;F6A%sI?a7%|oDZ3{+00|zwZXxgbKXPEZOhk;{-5YNk#%VF|t zfP4Nw0HH(REbyd|&trVrq04}Lo_y7WA%Ktp(VBB9CJ^y9+TUrT$FUPa!%oT}o|gH= zkpOTLtvii;s0gOK;)o!+wDz=;?F5FAIJs=LAg0}_o@vrsCYU01nsbQlpq*f;;#_x3 zqq**wcjMio=30o-C(YzpK;oPt;98WkfNeeL1e7)M6fv}g878RK=pPKKMZm_eiM=o< z=;m5M84(c_@9ZeLAL<&sBpH2SfUW>JmHS7MJ+xsv?1%3mz8$a+9*8U11|*R<%-$of z&>>TGgcpP9IwxPz!?0082`Z1G#y&iS#NpHj`f-Z3NoWEncBqQcC}0S3-fN4CCWhb} z*;(#&sH&oFvoVHE$i&|(HkEBy$(*B`whl$n`eI`u!wp4gW0aHLFb`R5R~nlY+9euB zgEiz?D?ZLJqFu`AJs)}*bB%7*Wsu}-pn=6Wo!*zihqVjJb2JM$0YoO&z3EIE2xALH zBiV?#gfFR>hM~rgKdG1^w&C=4U1~OlX88;-Ae|c3u;ThO;mpo{!7Fg3-1h+zB?^p) zy&ii!zO>Q}qZC*l24JhCk++aw%85fyVKt*LF=3Ewi z7!7kfoL*Pa?#LBX&Ss-K9u(`^1+3m4uR#{h>J0M%yan_kL zs>l(rq&jDsicpV!l22=DqB5>&xgb!j>}q;tjXvUs#T z7wQOQ2m2eB5l5H-C zPZ19$1nXPQosNL4R#|Kguj-EK2|onpI#(kq3L@-ktq-zp4w)yy90#}>Qe`K`i8HIl z?GP0)Qv28Gh#dxl0tcdHqVX6;rZ;PDUFB+pT&c?FnQG$@ep?X3kukRppEj3Q3F6DT z48v`Of0Sx<=$cw9>s(es+$+mIr_Ccftg@H8L*Bzj9+dsE4|WDtkIZd~UDIi*I19Q} zhZVtCITn*DyR9z8$uV~@PK8k3U&SGmhiSwR5SaUe@m=O+HV4x!nr89y5Cd3*n8yi_ z;uv~sg{;~s60K^p!Hxps3I&p;z^+(RtQM|X70v3GHJ7S;ofeN`32H(gfU$8`s*sK# zax25fr?fCltlOcu)e4NIjT|g|c!3oo6b9T?GPlLW9Bz!6Zbh_cW>XN~k|X4(TB#u3 zr2_2&1{A~Xj-Uxv=F(M z%%on^qWI{Oi=N?urb(YgGZ8B?0+~hA&2WWd(h$Q~Va@^x0+2rzxtX zg3HzJID_;Do+^r^Lbh^1F(9BCp@^Igw7@UB;e*5#OOwYI_jjm}HTC2pp$c6u-xcH`(!(b4chdI>OarR8<&l1Zgr}fMvxs6;NEMVddJn70MWNMz*y&YrU23kfK*vK(WbE z@KjK{Rmewz<0%n$}49>Dk-6fB=SJ}Oka*FP)hJjPr{0jED6PLn5Y(d#L?e+9i3MsBK?h= z0%K4PITAwYgPQvA2#`6HrN2Q)1x)K>9N8bvmLdLI1^;~$WHw~0in!{fP!R@xGe@?Un6Z&# zKuTEBZXwK85Hao`P$RxfFlR-hW7srEhNM7xM&HpURXl^3uMcW{>3t{<7`y`M!zHY* zXSFK9M%IX#B9(sXbU%h*fWBk^-2zD*`d3pwOS)57QChK)!FbP{6Ot&9cMy0*l8n&T zOvo{aSV!3ZnL169D_DiZf%ru{DDJAV@hH3G0dyKfj`(2E1IDAqqYuykk@gIlvj^}c zwMQTDM;wj@bOCX?ytTN5hs2k(^7yC(MFEq4cjo76(xaZDAYkNAOf`#lixTv1)i2-> zei}K9yBCuD36KUYl~$tb!Zt1AAtNg=G$4dbg9GrvBfnx@lscBaW{pyCmm-@bVML5) zd9egv^5o@roxAB~ZT_}N(|c59SuXi=LD->@zkS=XmzRyo<5P#IJto&WB9-ojF5PcO z8n(JWs*3E1@;@RGt=bb!qfk}t$U=qJk1pM_^t>M}-FDOY7hHgvM`meVV6EnWyQ(lo zg7b$OLm0aPjVjbPk|p6wS-ICAKbZ%*yl*o{l)=Xsn>4F$!@kDbpJBPjUx!oWj$d~~ z-O!*Py03fRhWS%#ehl96dg#2Js5^{VK-71!!a9W$2`zY%t3t}9vN+OKDcA)S{)@VSMx8qydGz+MwO!{SGBY*S#{~Ww0UY-(%O=qcj+qg#9V!G*P@8* zQb8yEypIn6WAW_hdox-PxnC@#7YJG_!2svYUGE z%PgyPTIbHSI%}6@?(3a&WqQ%F_WKr$8_$#;cBe(pdg>E_T}?aMCMD=lnAEnTDIpHL zf1*7Ru#An!9*{-szhXR_HI`i4XMsxIqeP5+mhImqW7EJU1pGz&MlB*zB;o6YFH10i zZ;QCuM9}!$2XyHI5qGp9-Us4Q`e_p(=oNd(P(~B@pR_`S0s0~YqfbIm#DN);bH>kD zGqzY9zr!XQIf^#Gr3U#IW>UcgGpqoM6~8@!hf#;|wT7P=KjWV@er9|M-_YwP7jt|O zM{4LB{JWAfbAUF6Xz@GLo7J012SOfH05?T!wqy zHueZ4`q!bdwX}y9ZH;8C-SN^)^BW%wwtNV>3J!3HpurbtY{r|mac)y9m&0(&m?i|V918hNUtuqPo3tOF{$Lf+1|o#yoNK&| zRoVh2=l+ut%_t^GD%0@z2Qe>Q4Jztvh#G&4_K7(u^$Fg$W!ffzinI|bcGxb!PQi31 zIfzHGpWvU+ZINaR6b(hlroNflA2TBM2jxe``YVOOQ*(soPKYC=^CCqD_J=biX>pv& zgVxMSrj9KQPgYPgB`-E#afgOnd_?O?TDZ~IPme53jvd86^=P@a?S!dT9C@+4z{}z> z_JBAQ`eD>(&ZYdj(O1}TbZv83-L&riAKu;rK&tZG8=v=->AmmFmMJ?k%T~58+ZfoT zEOqH12rJD6RGNrNaYSrr6j9Mw!fG^XlxU3gh9sL0jhnLW+%u2pEX?hT3@G2K>JV+%?M9q zh4skgAw@ogHWA^49)d4a&~6~H)u_rN^s2tLj<`*&E&)%~(Z8S22)oXnvwq^Z>Tv~S z>jL`fVwZh_eLb7GqPA5~4r;3=POK`(tBfx2uW0UC-8pv>yGZ^(Z3m~7aFmaxlpk(j zg1&Uh73<{>bAQQgt@+){CN8ch$WQ85#@tzAcEn~}q@1Pf8v0>WyAIn^Y_K=2;j}d4Y^o01 z7}hXyO#(y#mN5!vvB9??v#@~@@ryn&OdJ4d$nihtet1L-@y+#(qzI$`!B}Fc1Qm;G z2gr}{OYY6cp33))z3fsZ)oh!%(P*;D=K0o|`o$M+>Fk&|@r_Bn&9M*Jt-3M3v9YP$ zUEMpj%(;4;O;2*;T3ew_j#iYlw{#_^&#b7L6A=KTrg}(Poylm$8A~5cUF0$s$Gdm5 zI)jiYZ){rH(!98O6+F6)pFL@!g#D)h)j#?$Hj_0 z-e91$t#f`?0r-?GU06j{Cl@qc4OsNmI@L7ld>&LAh7q`V_*^-)RclP{AZRiG2R7D1 zgT{k`cvI2+UcwO0wj8Mwxk!D8|x@`cyu<%+^$I3YO65+#Tn;A)~`r(X>Fq3s`Vg4-?Zr)&OUI@ zw(YHLUb`btUg)$Ar%{)~g0Pq&9t1MJHEA&9Sg)6J3&)D95JDYhVulVSm zY~R3@pZs<-+>b-0m4sxlLPPmKuhkp^R`>H#0zeVD1KMAsO5~6EA%_G{dYlaS$;X`o`c%$4+aG6&+1`Lk~{(6e~7fu40fdmVqS zaHTTHpKEIZo(!vC!+c zop#fkcU|)Rj~BH?w=F5EnYd*^SGBTy@`j~s=ilHlM#jt!rA-+FbJExi)EK@nU z3LC;#RF0cwQFk?lI9;~DXDIiqYkl;ulXpC}zW32xrcQh6&qD2J4pqESs~mh&431sUuo{iK7H=FPc!?CtnkHOZhLUYs~2AQ>W+C=oz_vL zgI2on@zm?e?9Dusv>jT$Wj!4AEQ4Bb$kCSl#iCLTb-B=IzU z?1FcF9ZhZiEC`rLIBR&8Gw>M{1Og!$#25I@*f8!ZL1%cK`fO5@5>gWXE{zEZ;AslO$rc_cib)OrQ^$5nPGR-1 zP}Wo6Mu%bFj$sQ8@93WBgWn@k8JvxDusv{p%w6xK)UiIG<48TnQZDJmVW-LEoImRa zHaN8lv{WNo6%r4LT|@1}%R5}mQO)-IoR&CA8$z~%=3VpkeaCWNMD2h!MCN9-j9=4t z=y$a}vwg?;Psl$SO@I(dhUdN4huC4EMc}sYSOdX_Y2c=UC|am5mVU`M4?P)iPFl-js3QXH&7=eq5aY71-A zzh&35Psfhk9~#?K^p{NAXVye`Yhq2LknCcp?np;VS~m)>;E5$+jvcAyCy+nMtJPfi zlJf3t4=BGrTgUWQ8f|u6*X!GRf3k1RoP9s(UHQo5D|0mZdp0oF^|!J7m&ANP*}nVI zh1cyh=IQqt1mlWc-2Mulnlf=;j^_U2H5&n73k4BuSbvv)N4QhrEWRsAU(g2vtOF}D zETI{#4+a*4GSnqO zTpaivJ~v3;LD^f$vH^#;EEAXAGgm_;EFFmLB!3Su2l1?xFndSVBaYe8eiTRL$Yy?L zVv(6}bLfCd0v@Y4DRj~J3c36@@mu}$)6af3Zh2;>+y1jq%JXA~kAad*-TrB}KA z)ob@G3i>N=-cdGgQrin`)vK?vIXO68vdw=2P}isIHugTdO-cbZVAJ!{YI>H=8Glw> ztH0_)=KS!N!{A*W$4Riee!vp<-=A3@cpcoJZL4!@F;s`TI7;dL3M2*g)ffukZN(+X zuKw@a*Y}(ejpUct&zk;iX1x9O^mhn5;mFq@EXd8@2wCA8Db@S%+POD3HO+Usij3CY zhhKR3{VPBG8n}gHUwl2%!jAJ_1$|)0HR4XJqhZif*kLinLEjr)6crESgbNBT(s;Xd zVhprF+~zc;-?bD-h(nW}QPxX(r^PA%O7h#;RHXm7pIr_6y!dOk|JaT^LC&{}C2N?; z<`>6Vop}zuQK?>u!G$#|gONj#PC2?-2tD9Wa~1Cd%5>6e#MwY>${I>D*+M)hDi7Jv zX`nIhCrxaRqTw3Zlb#`}TKyGYf8&Y@h0Kv^pW11Z|)`DvS!w-8llq^x44XzmD5^{#af3$TWoBd zmU~=TX>?g+;c@1;qWk*4>=T67RtmyOVoFJu4>|(Xu^tj}kR%Wp+!=LR_ypw&tSOn1 z0Pon`e&yPGQ6q922dwJ|Vo4`S$16bph~ZlXs|b2KYit1?Gy2J6qqP8xDY~bRh4}rn zNuQ1T7o^e0Fwd)MdNQq8Y*-I^KqOSY68uyOQhW(C!epDI){mnPNM=IwXCfQi+&bs0 zg?}1(2x1u(h7m_d?BzjQyyvL*=no!g*pcWU2m`Kw>#RDeN6o6~eUmm`zVGsllRAxK zj48{zmK64#sWU5DTBWMIyb8I!`R%9`@Jy7HPz zzptQY@JcP`PNnUZ=Nt=^ZlIu_i_B$0FOiAYHcpagSSUDXzeG@?HaG0)H7%q z-esyqf=k9c)s^LFpUYx4D?dlN$Rtk}*@M)NDj4O_J}S1{qvB7p9@GN=jJOX8Cb5ME z-z9{zfRS9E4_y>cB&m-;Lb!}Z`H6r5fmmQzbF&s8Oc-v_fFym|y2M=sj;W z7Fu9~{=t6Opl7rfkqvrO8PRlV`a(d}4EfQ0&}A9*ozT~tl>Uqx2Y~lLrgmMhZ{G!-yAN(%YOCvf-o3gFxMJOHtKHAH z7xnfQwI>g*Us6y?v%Ium387~UpLK4J7$+3fmAY(8w;tRLyX!CBc?U>nXba+dQkk}Z z{w~YEA@D`#a04K^4faRwm;*opGW($CB1oR*4S}H3EFk*8qZIgR1UG&D3m29Mg%YKX z*L`owI2A(ruD6hb+30AEQp{Gk=m^svDGJkZwAEqM2I6nsMVH1+LF*7IH~uBtS9+9f zhu(ST&|dfN_H$^B!ea1!PURe~y*uE4iS9T6o)BcD@OqW51J873ybVKCS?3jX3_UY7)a zOT2xA_cV`sVkiy?^%$^aSz}$s6HA-g)SXOrfBC5n+LvRR^#^sycMc`@E+fQCQo`EoB@xF!=NHA zfsWOlpaqe*fQ-dkNKF~X!T-liQOCy6R@Ct8plL_;Qql>zKb^v~82pSTfoQ@+p|sc- zB0aQaeWQ=R?B`fBSY*Y}-Xn2Zya`_lI~TMBDh}>E)B&#TIgA?(8lTP)ro5;S!l|H; z%(H_@ZPa?177g{7FBNRmxqO8D95R;o6fEz1+4)AZ@=G&(*|1=zH3U4Ig`PqBq5-l~ zq?5EAz6w+5UiexZOVKdYVw{%bcPdvDnAte}0m22Q@#_ysY_?<`ZyGHh9-mFhtLe&Rt!PC6iPWR9S-0A{_kO^U?Ryi2JJF zN8dmC{QvdyU-!My^=07w)Yy59mJ=|Ukdbr_=YcOdqzhcfjuK9!Jv;X(A&WvB{F4lKqf^lmBaD^lL`c;Pp}}LV&Q0h8w9X72A}Tu2pS9PfhztZ=&$^OTB=Zlkc=U(mA4_=>Z{z;z;5oqDWOOWqEl~|` zK*AyWCRP7NTp^d9PEtkKSKvRdq&W8@^&ji+8|D^6xX8%6;3T#A_$!%6aA*vF8eK|C zaZ82P!gNuU1uqlpVV2WH6J!;vPt-S(A+sJXF}PX}69%~SGRA6sGT`}%uAp;Ui=DirGJr}G~AWfF@e2Uri25lWK`;eW_sRzryO4TSnbdVk8V z$9{nIg>V(Tai|$tLx|VS_@8K@?*N|{28F04FED~@sCOh9!;N9ENkZzlW_msBPGFr6 zy^{>FfsoiAN>aSVaSgJ=CHwpP-#LUV6RA{xXmEh@k11})CH@Qf;?}8VT{!5BnghPiZh{PbNDGfl&If7yn~~^)@3f4VOz* z=?oQV$jc~GBot1aSfk6O^s8l~Z{S;Msqp!cB@>b;i(0DD4+za83nqZio+6q*{7y@q6T zC38DbbnG;lJ5V(8T(T0l9;5J6oTjSXSm&^y2JAUIWT z^LNf<7O7UGenmO?Ecj*}$j&}hpD@i#R)Kd?pHSU1GwT~PzF2XJ=2Yn$j~}veKM;@* z&OhJ#MLv#xam04>etqLc$+HkQmaTe@*nHI26Yrqj= z7%Oir*D?*L8s$MMtoY&xM?KyyBC!_qZSIYJs;>*Y30l}lju?FKD;yU|a~x_^4fO_S zqN|^pppT7(jtBM^vdPrVSi#|wJ|!K0M&B>a42432{051(x$BP!<r4Ia2H|W6K_y{M|oy>w%HT1=}LV$iEDpy0zd$CH<>k^;<>o)CbNFE3nbK&MuV1M z0)5~@{_w(k@*70WrfwzGy@^cxSmY38wEkdI$w2oe5gMkG{vagj@}_Q~pIig@@_2AP zm|ykwlU%1FpIC0IfO2M)5fEB9>o7E`p=SE(8$`_sCEnD{P%trdiXWu@baHfw>48n% zr?^h#)`OQ%YWtyYG9a3ekkM%VwPa!qh>e0$EE`pj-IG>{)UP$(?3K}b^$u>E@Cw%H zNDeT4z0k%v?(|iBC#8A1fc4V{TbJ)$zI?Crsru{lP{3~L6ZY&~MwuU%?R^Tl5|CFw z`9GXH7gR%f`WkxS^y%V1=+Wir@2WrU=K%=H7WK)!R6p>s8J`go&R{~%j#BOmnLGSM z)weO@={V%42pulZVawbi3{F&U)T$ne`AWiehp++_oa%q&any$32ClhCv>|7$-R6+x zX#2{|-@bL_06Au9kc3G?$!&#S-C582zNh>}7YP^~Zkr*h?QC4rw{1Z~k(mN``E9fz zG*{*9%ZNUr4k^$9ns?Qj#i)rJ)~-qh%8X2VImbRSoROmmb}$tbikKtqq6@|{_zqM` zWDet&F;#C)YIQO-L+PB?Hoq;8Ho~`u4xik2-k4jaJTT?vvh(&OS01=*?!9v_JFqf2 z&=$Y^`kx+if_@4CA-)CR9$z1{OWJLiww>^%QokICe@ z_x#0|Os}w7E2dw<^e^w6xv4d3(7ML7ub!~um5&b1U3~7^+4G~JxwF=uyJ$`ys+lvd ze1u+^p}I7!zLNTKYnc|Jcsj|Y)_&Sj;@H&aBuWDU|Bc_qVFiWvM`u;yYk+PW)&K`q zfJqosbwv5G7JJ;ZD8cfD7;s*ooPxorSjKvdQ1zU(lb4HI%za+%XZ6SWOO^(d-#hDJ zLtU1~;?84NiBxD_B(iV=vU9&Yu2Olk>_Eq{{-NYgknH*!PV?G?)1zfY%8h<|w7iII z@IKN<)l{o;KWnL<^xgJm<;MC+uom!VLwlF?Rab_nUAert`@Zxr?ed+~xBZnyw1z-zi!t?CZ=;Z^oBpWgfh z)6)t)MvrG+19H7wIrLJ_yghl{yd268O9z5A$>V~i&VQqBdVkH>Os%T&0)9Q!RcZY1 z)vY$K%AT#3USE}mstShxY28e)5D)?Zto*134Kl9(`sP(i#RF-`c!<7D1(f)IuO_Nd zkUjd}Dtv~|!%kggXnp?%8j`F(S5~1^Y}ddJ7zHUN2#9cvn1o`)X-!$3&~@Y-3dzin z%j}fbU++Kg)`9-l6|$Is-I%6NFat}Iqw2hKn_yO)9ffJ4Q9TrWbj znEa?|t(=FrmkpZjnoD@(%Xc+DLd`sGtpA`>puj+&A38?fuAyVxgMPz3s0FMGL)S;$ z^R?G=zmU`qX6L$BRL@BcETgGS~{AjKhJ7Pf2?zvI)KZ94ZvJyvorWll0X zrv7B-FR&|pREtmT6n{FHqCfhONL%VY!qP+mK+nC%k+%?iMdoDC1T38n@;MPWUI2KQ z5oW`Tbub$pN632ILlcWCCB7iH*KB+oh6ZLz$d)hlj}Ham`4X}nASbTpGuds|vgIA!VFs5M-ezqr|;cg2MF zqHa%FTfDu|waF~ooe&|lLv@$IO_U<5z+}x9nul7Qr@_UyIEHs&qSAooAn!1Q{dv5# zHTV&Y1dQtcFU=w*AASDCA3gB;Z^gg;{YJM-ZnD(4Dg))wa<4DoTKnh*m%Ft3{KNNM zSrNYB*aQEgwi5jP_BBuTu!o+}pZAlEO4AePRtx|nDqri@xwIxp693p-Z_plb2)dsv z)jwUzKK`FIBjo$h!nd&4ff*qf>ys8! zSVvzwLGvO^Qm&GG=5~ukV%yXM;aexIz?D=ZRppe?z;K<56h8VH9(G7Ri)>O4(!D3I zTt>FUocuBHX<9h-BwjniTN7?2K=pjcWR6ru&4-BV^;j*YrcIhz0T!_+4NFm4Y6zi0rFktL`@1=?P8_+%0JUtJu-HAY^ZaPnl} zv0^Te8lOupWYV3CDYs25Jk-M4Tg~h<<;I1w*XQsl_YK_{|ieD|0pD#%f`dz8Jm=DbP^?{3IMPVZQ@L0}Xrb&VluYY*2|!|KKfGfEQNl)Qp`sG8JBjxjymWQwxRVPUg%&?kFFB>Oqkfp2r_h ze&|`JrjOF(yz=f5A5&>U4<^bW=ADhlw(+@=5k(_kKT>M(DFV5KL`ewoMB6y= zb|Sm7AoTme(fIj>wH76&lqbeC;>_mRGpnWM^tK6Q(Ww@v*>aaf)&hXSxWbC)Wc*%f@wWlyn;hxH^nX*3V@QY#1){<8*&qTH8;O z2yLhgE3qj=8Au;Yob-r~xDfk6WlD%~&b5+ZZTR(t`7A-F36{@dWSxz%&;Y%gHj*~2 zp<|J@oN8%+Nxnf7A$=F39Vx;;O0Yoyl5mO9`Y;DQsBIW8Ah1bv!L-O7iUF#w_D}+% zGMWKdUL@dAh!=lx$PcVNgVA=YqNJXA@=D~F5j?me>hrEk zF}0Oe@47&2-nw(HsGh!fMx*%tJ@*Wj8q6NI|L8p|%Ix>PE5(6NX)b;DUgb08cfvg{ z1@oQB^&Lp(9*$QhOu=Qbf(hGKH7##xE^7^UtK&^3|1oh7>NNSA)JZ;doy2cgrw`ML zB#x|8_gUv$F=^H6Y0}qJ>CKmd73{xMI4JbP7$PxR3Dk1Kd31m6Tx1>p4LUp z@wYhr?8ONN8b{2AZ-UMPm?yCKAbG>V)RfSNvm87(NFq}2AY2T>#Gs&MRo$tk{K3VB zMh|HW315RE(=bl7sU@?=bX9c5&IvKEDRNP7W!wDdnCMw^=ATy>E3AxluQ+Ik87x4P z6pCWv!4=)HN?bp0LHAj>Ykphu{VE24RDZO*!aJ_IyKL@K_ShWyX=mc*gbY^0SU)b- zS^cW{(#E++Sw*bxT%&Sf`uZb#*WNA6UUTL~wF31*p>k7d?-5r|Er8S1Yq?dmbSg$X z8K76t9&ex;o~P1b)KLQ(sKrd?z73!?2(tyODHd2n3TAv_q@_g+RUN96i;xsj$F3be?FsRrv}WObm+YL|70>|^HqbS9=Oy?DPZ}W)|}&6$GBNa#>Ps4aBI>#@0P-jb3sQyZO)h@V49r(iNt&$3H5;!}7rR}n zLM@x7w7DfmiQVFJm}OVfgmq1MuuE83rPajxMS%U9Wp#M>DE)SWj`avm(^}s{TL%Yd zq>G{T_Z4oeYMB<+M|I{JzcDm@!X#&DIn^y(WO52U0M@0t6(0|Aep?5N_)y&t#}8&f zqzrrBpZ5ba?Ly9x7H%;`bAdj za;+sPt{GwR&${Y_%SP#&aT`M3YjIy4ZlwG8&BAX-DV0ZmAD;$0OfVyqah8ziM}A*; z5ua0Ehu5-NmzEYB68LeN>RI`#vI|`1i38@=wEgW#soIUjIyO_`B6g zve6B|)D{?BST?!=PSOY2=7-~q+7P44AXc1EFSQd!EB!y>jevF<(P6^&lk`E7$BQ^f zie-%$Sp-iLb;-5$F;_T&97A$UT5lh`x=L8>edcM)gI=~?VrSN*ciNODIh9KPH2n+l z{s+?^yjx#?werDgwn_*+%HBA-^3FR^Kc+Fm7WyyHTxfa0Xb7&bPR4s(a3f*?o2MO^FFOBUnl z+m+2qow9lR>44eRyFoE~yn4NDb;oBn_7j!qZ=MWi$jQy>$&H_NthVX(Ue;rEO7HQd zcd$?C^Xdh|>DS(K&$XumNSgoXcG*`i-Q^Z8=iK^tBikmE2jt{!k?-;g=?mPumaewD z+)j1=bG{*p_9GEN{4@ERNFlOUajRQND8m^9l041Vuo;Zw|0a1J zuP3P*^mU~lO$wbumL{ljJ?B=k_79Cc9s<@%2sVPu->J-2Dr_zDX5yXL8ETSJuJV6i z*v@oPbCvLc3R8OqBAV!VVLsUlRBJ(c_t#pgxDEx%la#2+I)uuSBMZ_JI@+s$^f^m4 zmB3KQHx!q7vSTrny*m7R&JndGbUFBTijRHnX)?MT1fG|bQK?*`&vVO>^X{SYu;DVW z-whQf=P;wE;WkMfEL-(tY0c_sV#tgZ=T09K1zJey(HmlMp^^drL8o5#N>25M6Z0|( zs+%zTzD0TBeXHAHx#cYrb6QdsH!%Iy{_tRwgudcoo}8pIbz`$%TTstI+|jL3Sy zNjU@s$|M6>LQvBL4lNYo!{k;~6h@YJyTf(@T7LQ_=QJlvx}2_9Iud}~;OeVI4v86e#2%D72=ZR-R_-g!LfEly4+`5Gxom zx`F zHMZzPjl$RXa**0!LIBz|SggtH3Nt>>GFY688+>b04M| z%{K9m7` z42pNhNJ|P|(SG3i#$rV*<@LfDoTf7I!T5%TMw<(~7uVN-T_Bx$Ba!1Ui9d}EA#(ZZ zFDVWx{dg%Hj~)0VR9dD!ivi$gF6-bO(?SZ~%Th)0n2<8{TisyxhWm}|50J~Vtk_U; z886|kaWOqBstAV#tnr*3tN2gO=C~Nn#I?CI?IYZyvSPSLz4;cGcv++DQy%$7 zV-=+FtWhffR7Vt7I}~>Ar2&;{y=RA!MooXG+Pp*hJ6nk0KWW~g8jIUw;b*R zfV@zeTaw}aict(VvCbF>L^>l@EGeoIBOyTh2+vA78{K*0N2~|*pbv;Q+kbJ%8BJm1 zJw_W~vBmQBmG@pi=pj=|Ut;`Gfi{Xp4CS~Lp5Sx{OMi;ZPXGBh z)QZa6+%fSecTyBqjN&mdGc$4qpGB3UtcCiNjg>HaQd)H zOmwlNZ`-NM#J(GiMv*%_7*vu)%J08t{`7}rCCxk`zLeWe40KN;{ug+d9#ACM;BCms0xyxoko75^&Ewg^8UTAw+Fjg3 zCQ=#xayr7tC1Xff>r)R&(OgKlQW8kB&nvzX70pO#YjOF5=m6IT%AMm^P~T1z#11Od z$_{qMz}jWViXxVYUW+8z++a`j*z0zKQS{3}#gCLI&)dKu_@M((c8z`hB4=?? zz6U8)EEe-$51Bobng!{GkZXp?Z@Vm;Ev|86oz^W@=W9&k!}l$R$RvvtM98+1+63f* zErD34*=*ZnvTeH(X;oyr011$24WRZIM0<=U%A*qFk(zw2v*E@+)LW-T+9n>K1qw;h z2EnXnG&$lRn!FRB#FjHwP)%2S{<9|!LPR(d`E-nOX-~z1URF&_p}fq#12)cUkeOEE z1g5qjmXkae(F4flF_!v_TfF4BMN7aD0Be_2UR!u9u_RB*~>*W^L z#2ww8d9uTHrp|6N2%GoBVsmyB#=7eo5*4$mCXT7hb3A>!%W}EZIc`Hot5fSR&(Yhg z7SY$(zNmD?`Hs@q^vbIGrk=)0Fe|M1_S=C6sWl!nlvmXH@vX~|^Ts5s3g{Qk&aa7# z@pJD&9U} zai-7qpwHUT2D|})bmgUF2H?IE;DXf-gmyV&mO-M+EMHD5n<^!GeGnMMJx=SrzSqBh z4=c7B^`58f2IZxGKz(f5dxuw9Kz+k*ANQZvQPGI6aa#XY<+vZxVCh<`bN?gmhm~9G zPN$h|e8FJ3$l_W!*J;HMn_ZSm>0TVR%_Er)nnUq8$_s8iOzLt9N2fAEOFU#aQdtgI zyS+Y$uP)LJB07u$%G6<|;t25p=hg~KAHbj(puq%SAin>N@-w~O==_Dt_*+-ZI7as~ zz2|2Rqd~9y^0$1<{gFk~J*vW{Ijv_}Tnn7mUW-eZXt&#)%A)up|6&Kb%VoDZ(m!!o zdacd{F3Xv~?0C%LB3_1sNz?%_MmVG;8o^UQC5VQHOExqZho}kRA!Vi$ckqy0dmx#@ zoWVAxpHm)SUs5|MI+x|1tXX=1t_&c4KKPt?=5srhB)db|{jc*zJFnrwjVSvz#KmJW zkO~21(*q&X4iD`D%{dquuBZzpT|i(W!Yy2zh|&ds!KxQj8BydTMvU@(JRuI1c9n%nr@Ea}KU-3@g8l2;h(3 zxJ&0ha7; zEw)+Ae&uG?>sPmCfDGN6xdB5|gNR(|eY9h(W-7-S@=~%B*zG*g`bfeP1+-`xYlQga zs73m39M}758i9M-P>T(6Cf8L;K&1!pXidA8POvoKq+Kgr>%4K>xfWgRtaC4#drNoe zEzYT~=ZZGgAQ7C=GGpWG$?z?6OKzEcVQ<^3h2>LP7uU?z>zm`9)e|bK3tdz4id$>C z$|mUKmdM2NmUyvKOg%Ou|KL?q&YE21m5v`{gFrlZyp|nctf=!Y#s)tZJ{!~(wVaW@ zy|}43&#V=cA23li+XHaq_##{z_90UqgBpziDco07$@z2)A`GKUj3n9heKJW`Be-)( z1OM2Yt=9Ct2p|m&!9s)}4*t$+ReG)7P)XCV0a7#&$^)hg*$cAoEy28*ic#r>&AikyCWxU`fMBu#@y zmCe`??1VGtkn|4`)M*#m$_SZeqGm2?R15i`KB~iFgtTKBKM5{AsRj-%Rl$T>&k(6h zX$vstFrdO72Ij*l18X@aqDyLj>X_51g)UoRX?uP5>{vfg!6 z@7Qp?$%&oxlo_!xr`{B4n_DySE8F24)cf`kwR4@a6^5$)=abc1862*jbkPY-Uht0H+lK2ux|XMI4{l`5X%E+^_8EOH zp*F)6P(mkf4WVyTokz6Bum&bHRKYDLYYMhy==W1L03Y-6OPRUeL0-Ty&?rj%4DRyO zV?G9l9a7LF;2=eJHb$`!kdr_IFuxZ1z}u{u;aBnNz<0vi)c8xT{bpyN4msq_cf)|BgS6Uq5ZjjE03Lt8-)f z_Os_!+x5E5I?1wakuU$+HR}%iM5x-bg*~M6%XYKH*}U+{^p>IdK2-Nc?g2eq_phdN zqpIins^<6xb$=zdeouWxLr9s*AN&5vYCkx-nsV()+k^N3lJAq?14s`Gyg{|s;qZaZ z9F1a)VSv;g$Q?%c!?ZfWW2T&8u*;y6p(+6kVLMbN$TCPMzHs~iLm@zl^b+z!Fcu32 z;(gHKKs|#%`%oY*^)=eWN{7RiFf=DGEuP_+c-x|xJEDPjah|`ox-;wy7z{d7zS|Y3 z?5Yae;5F)UA}y%IJhQg+(@XG9AvhGYfeQ=AmxpGwHMNb4ZJIPgC<+FEy$}ls7w5$U zVM}sR*x4E@O_aB~U7n(vlGZ|hd`5Xh>vvoEIH0!Bpe@Lcg0}_tf60vH(Gq;j>*3Nc z(i6i8hC>)v3Xm6hdt{r0+M`9p%s>ugYB%?(8e&}|+dND8yQH^@P+u~GEnL-A8F0Dt zO*(@i;0$+G_xkgSHjIqb$YXM~<~y2)HNU_psjnk%cnp$8fVM?E@D)QMyJ$V|-0Cw%yxNTV-hqL@ z4STqS*hkVb&=u9#2YG=zz5)mZ!DBUzbq#ft$B2SJYLG5~##cB*>Ey_72&N7o|Is)D zd#_7SwrISomXe!-RB^k9s<`t3e1pd@K>R|+E`Bj9@MpEJ;!On(7!V4cm^d;0O!u@| z?1vqRSlFPQh~zVFFB`8jkBNpmIzq)`%(`QOXb#rb6?ohQYlEIkBYrJYE>0!|kIOi* z>r0H|DN_=(z zXX&q4D~89%QefWf(p;&zRr4U1)3GK{=!gvFudW8!9e}Irs12W_Te6*3kI_+2}5Fa6|Rz#;$&Y@aYcI*+OLR85Ifc_Il zsQ7%s=k@v$Z0>2N4K{C3o?Ew?g_bNSL?U3eL~pJf+rSPRfSFsiWJ$%?2KaQ(T?(>R z`J-T>qcf3TkeD+t?VKXQ?$7Pg->5>{xAWZ1!R7>VrXp_>0#jO?qu|deH~x zwsdPf9&LBarjO}Z=XUFGELmX~{|B>8+jr)C<;%$r&cW01?gzW+C36)^V|&bB%l0YP zg#~XJ+eJEiHCOJxVLeNrcagK0G%Ss-8n~PiPfw;99rI+BGOU5oMPY&Q^I-fFkK34L z><;)m`#vcNh`% z`U{75dy1ZLBFFcxr;*&*{$!C$Y}7e^TPJcEn_M z{EjK#vsx|1;v91{oe-386aqGTiwXZ}zhdNcQS~X%S&+{&tdAPi(vUT8BF7M|lb~>X zEK_a|3dYQgW<()q3KdOJBpkNe5F!tSyxwiaU|VJ$bPIth*<4t=8w|=~s76xcjV;r^Ndv!2|Tm`_Q^Bc$Egp%h(`!m?xpD zhun{UjUIy;LifkY_Z6>Pu6Q9+`>tmTq3~Fgp2HR@PUQ!3C7Y}Gl>68s_BZ7Ric@S; zURM6X#w+ihrThUmVj(`OhvmcfQc&KNey99Jd4*Y(e=7e_e$EQS-OA6Ef3mRShR)Hi#vojI@14I zE394nCVM-jMAHw8p&mAXc#2f{?RVcM1P&;NuM-~Ikv_gd+>yShN4WUt9fuB~Ur2^e zW$f(~7cpCNCiNCvGhhqOg2-kw4i-n^;BBbqL^y)N?Un5CBK+it140J^G?mb2v4B+~ zC+~3o#_hwMD`i|QLhmV0y!RfP%H}rAXlR(BOtD@y^@0TjH8b2M8+1Jwjy98fMoqzj z3#MLm>Ys#jWaGQ9ELIv8zw)k8=Ev;UbS!weQwFK zsbRYewI0S08|m{>n{CUi7lWFjNS!V0mYomn-1(635Z}pUM;^*VIe0Jql=+wY9RVwl z2j6jp>|BUwpe zJOj%DKR*`|+QTmqsRyCF$1jxYqOllpO@&OX(r>Fz6y(Q?yBarIpIteAx+q=0Z0UvX zx~G;`D{m_wl~pF4h07XS-+gO*{j!C6o29&X;mgmQSvh5H(w!I5I{zdz4tTWoM*|Dw z^0M%ta?2M7Y#xiO6AV#Lz#tYxnu-f|9br4zm|I)zOt^dejF4mQT!+)#;@GgIJpY18 zOH+FN&BBGjs6k&GyWt)Dd07)ZWRx9bf#agDN^};Xfy^Z1V zL370B9$VOX^{?ap6namPLIp{p651@M$W!)ZFh?Xfr1$WqS>b!9Zs{EBmYGia7n`X(YzcLYo%QlZ(RL;@Ej$1G zW+C+3z@pPPE~=1q%HqNF(ZafVBx209)vK9b6Hw>Ds~@YVLpUt|Ry&N+BUe{x zQ+s(!ab2E~A-%&9J(Kh5*L3bFTXgHHNtd%bbK7tF<6h<~8RKKu{DMt3mM`pGn0L3b zeB8O~CkSk;RFzwO^5IAdY1AE&51LG_h|y{|;WN8MxzlK|8kO5EdV_mFje>*VWmi&& z%S_o_E@^-iLdQb9Jw+J7({ew(Gvj+g%nc9GQv(5+S4a=N$78p!<@9#8$|AX3$3pZb zX&`QAc)60Yhiu}(uJ7*!}?0GgVC;cu+8@*41W zYM7|)&%BfLa%A}$(l|li0v=4;PemA2D&Z0|1>hlbtAGZ=JJH4P4d0CRjPq#4j7Ub3 zR5T(Yd_(1!i6`e$8-9mg0E{;d@IUAv2%FFCl{Y8mU!1C5x^P0T=};&f!HN9OcMt3@EQ~}Z z6el}smv7$rtaM@9^y%XpoF?s!XKffG+Tk*;`on3szqgp-4q(NN!5xAk_tm}d{q#cm z)20Tuk$aZlOmAC`Xv+VSK3k|yZy)@4mvEza&ft5(?WjM|CUBDSZoJI~-=jw0&@ILF z8uA3wx~0q>xY6Xfsj`lM4Iq^^okFWceT(a4K&p38fFyay!x5pOi2Rj6#V|-|W~k3X zBgWni`FtTSI}-AGL%zXdrL8RsTU({s$%^T%3tRWKmX)@$X_ZOg2OCm@t5Ro8(U~o} zsViPzF;!)1j1y|uKgRVwh&d(?j~x0Wh%%UWB@*bhouUFo%z$-mIqU({`~Qn-cP z*!ax0ZO=4bV$o^MdrM3AnzcGh`o`>2Wi2gOM~UzH5>28eTF7|_sk zXfYgWeA>7Um11$CJ34UNP;iK?z}&7&5W@r74Sol-ntmkChp%*Tka0Spg%iJc;e=F= z1rWIrqsUy8poH?c9V;n**KxcRA3}rh3SzE^sUq4h(vkpMw)){jTwM{cd{O|2m9#E# z8l6^wlSF)mt~55l{Ef%de_E^=o(3#1Ae49|zNQwG+h7}L394;}%s}PwczrcGEyP!< z5kL)4rG^A@Oj4Eczk58x33Luth&=eDm)LbU=M@T67%DYi`^kmE3adPC2zoy?0r7^c zo)-{rD->Z$!5gWJq&cIvQcY0ycATTujX0;GHPB7``?wd2CVw;B0MJ6zsF@ejxA2id zS-8n$K*C&knPf8}22Z(Fl4McT>9mMHM?4i=Di$;%C9Wvw5Cm_W7WIc0g-wYf8#5U^ zPK$+EBY9p)a+?yi7Oh_E&5Pw5O-}F>jy$h@gOeG?4nkzQlaTh%C(21ByJB#Q>KyUS1>$ZNo&V9zUc#3SLL*CGg7tx0DQ^Jh1B zJ*8fe6&6^WzS+oztkru$5|Wz9QgNkRBDwE1*u|nkeW|rFAz8FcbQ>$rzqH(EG7I>m z)+71^!6A5U#jImi`VP^gH3)Dj5KSWcu3&IzWrM60L~E(jV0y%87Ogr#fLC~vY!Pkn z>k|cL6eOtM^vrG*8r@z&=l8_|aeaJ6zGH3N=`%(O%NM$4xXY&$*X9@8m2@SG%lxu2 z!rbesX>em;Kn*?mE$g0LAHn18dV=&kdaR!|RtKf}0?QWN`>9mrTwyyfIrbH+l z7Ol)`3)q9w8s=hJRE60@lSQk{WqLqt>5T%j8!eXyyLPRejn`BKL6DQ`m5Z|7Z3rjo(QNP<}5GCC>sKmw< z*~*Iq(PUr+E^i?#EtYInvyWK=vfgKd1B-*14Gx1Qtz4VE}KCz z2=K$viokzr4VX>sMFvrqH-2nqf%e{U&b4~Kr)YeBKH_vHtTBfq-{l5dWr=8Osjl>Q z>g{?#Ht6c?wyANwwlc57SHN87hCJ(*1e~#uNi1~)1h~&IoBJ1fq<9vMuuKZ}Mu|BG zOb$J~3Slb`it>koRxj9?#iErgG87nQkx56NGw1odUU)4#CD*i|UFS3ucrlF8N%^5X z##${H)@Fyvx5#848!I-LC8IME=?c4L(PAsr`psUGt<&l-X!G>ikX6){*G)(`ep)vz zV({C&1(bn%Z9}K~+PY28p0=aR!wQ0>hdNhm-@LBnl||K4N(3PiL!;|m<^nlpo!>Zl z*Muo@xH_7LYUP-3O0g0gU|fun(LMpqnHWz< zVOpVmY6@Ra5|D|I9Eb8599l%zAjh$`<3w`B6Z90PJHUN{Ur<916r7|fT`36mh8uQY z5w$(>!QM7cNcoj=kS*@6xqjb{cuaDhdH&9Q{UKH!4Uw*sPE_5PUP@ zmMD`smh4K{wWu{IR#i=wg^R_MI+zEmpX0x%Q{Pn z%L7&8Ha*bOncCP9pSG~|z-iu4_k`Lx)ulBBHMRe`uj{gn6WNA$4(;ik*>$aQ>?a%T z-I)_6(+PXCW?nHUt>K2w_Y3tuGSKK3JgpeJA} zu9nPPjc*v<}}C zr!o;=4P}x%z;iZ|=N`1-V$|cJfyKSsha?OPCRaT?l88ejU<#BFe0(-$2OuIPwFQ5v z_}qYKrHPe&l@np>F??R}mx9`oCV;kfoyk&Xb^%XH>AB=TF1h4C82mcQ*n+*v8k-Yf z+n-iWoLC7k(ty*(Zr!WgU)EGo;Ag1~88a-{ei^=QJNYZ#JXd_cdb?J7yp=Jgfl&?r%6%VE5!Dp}a(FK%rq_O~q@Qwf8P zw0IPO`GCFYoz_zn0Jl<7k{@A#qMm8qYfeHV%3=F^9bf@ALaNuON!CCRkb^b`vO;lc z3BnXY$T_&PdIuCaaKR)Vvk^hT;3Z|SfJH0@rqbg8UkcAlAl39Qz4eU`-nezCx?>w9 zyYiOBW>wyL#27L@qP%6bS(LZn>S}o85rZt*SuuWO#g7;whDYF}XtS{5%#VU;_%(Q2 zy-n^>UV^uncKH_;%NNVFa3^CmJ+jSV{^ARZ9lx>~^;ff5{Z)AhzuGNdd|~E&o|1ox zcnc>+s3t~qjmVmoQ$S?bjPXpeJWF~*F=vwrl7k$7aRPjvj~kjEQ-1wO@2`#{9Bj{i zEST}-%B2IhQCiro&oJk=%N@?}!leg}-f-SIV~VW0zo9k_kM-Z(s{G)$djM9r%x~<{%zl8z87|Bg)w7_X1%=ihNA~+oki9X%xP60t=go^s5dyN;uCnZreU;=T1w`i zUkGb+XE1&_s-fwu#a8$pkMU!g!6aScR#f)AVcZPNWI+=;-ly$>ZeSvLb79n%LHI>X z5FZAhi_l2}9-%5TNC6cC*C>J=gc=5ML^K@27!(;$9|qYl;g*aVR6P`V5GVZ4+NCS>C}&z@y7zvDBr*R zRm2jwT+hh%F(KsC9!v!j35)e*IN8>_|FWeIVUR4YKB&G%`MsdI^v6HO1V4`W0NpNW zismw$Kypy!IA3j%0B%5lpeJkNSRJ9klzeVDZ6LcUlsBmxcPK{o-uk>@3&gDqGT&&PP12*?Rs~e&0f$@R+4WK zv`&Lj7OXmLUaQ6F@YMgu+2kd>ygmJa0$ zLyMR9u3A33)$Z7=9D2ot)Gvow+1lc%%NMU)I4`{Axy!eV&#MpUyi+mW*)dDteiZ?2NZv#A{LSX z^PVC=OG;%DkYJ3q;hK}=A-(^rg0^zTE#)ZXWhIIX_kGTbs<4RMqaECw z^OR+!T%%OL;S{Q@$KuKbtUn>L3>s{NPa;(+8&4Tc)l90&@vkhci1DuSe%W|bt}}(g zoU_Exnx4SZQ(ZDjRn$Pz!~<@J8an21QylE61G>b1@{clSLch%M!DqigOczo-kUcZY z_c~93^q;ZkmVOo9eY+{<=WH1mwPk~paMS5l7UNeHewwB0ujVg7V~jx zB%&$E69ch|P*uay;0k*X1%dDd@%Y+i<&_`brhI8lVsw{559K;QS5z)WY=sieSa&+hc>PRv^8^ui>saW>m|`$wV#Z0Cbg9~md5dDQ5Ti}sbiX&rtCe?s zG(0ynO2u8_&k1YNy_+iMxaPY`T2$o`U6rn}bKl?JIo02P#BTbVR4#mD>MVcfVCf4_ zsAUuFo%V*32V?&idk}_c7unEr#*YjS8pc*Q5)ynu)PcHdRo^ayyedAfUo9 z0a6{9zx*b2e;e^~#k?=X%wKq8BCavXDq34B5ONex+_;b%m%ULxZf#!P+Hv}g+0tlq zcw^(~QS1+IeNn#HnEM@#_61zDc| zqGrUzLuIm&l?AQ3nDAmuKC-HyMHjoyW2qh<%iTL?uhUx99?RVqP3-_!t5iOUR*v3m zu~v<$%H22TfW4=Ol+F=eWPTi8J;hgfyTw^Kx-{?Bxd-evx^hcY(N>L&mv7OWxtK_o0_Au^tcPOYz>n*WCab+)oBlZ|JV z#j<+3Gs~)j1rLQ;x7Ka4Tg(=_32Q7-`D@R`nw&mC4*Sj4^??Bc($}QRLvo=7#tLRe zRz+E6aF`=~sgp6m(oF$2_%Si}*oM*P!b|OqpWxA(2TF!Zrbw26X#g`=h!I&WS<(3u z(xvPgRC_X=Dar`>O9QYb+C-D17ak!Vp@CG=Btpf*U6fun8p9m2nQ%Vg=wIb_7M z*AUelWvrRw)KVjQbFCl+r_1_{i|4QxOn&X&Pb+(FCi6+lm)p00DI6BA6%NxiM5J|) z>JKlu;V>k?>q*^1>~`YNBYcv8aGH~&q^XDAQr_?wwvuvWVuf%-B}4DArdT7|0>;C zKVe6u6e~YsMJf>z5LdwB@v{W%?fw3zC`G%m2m5=UUm?Mqpb_N-@GH}f5;O6jF%jj| zjBpU&6}poQNm=Mj0fpU!CZYzcUVd64{kM@jB)lmc5Z*k*8JQYuiIr=!p6=q*Tyl9% znY6Z|f>A1T-8zMmsi>$^jS(KSTDeZ_<~o_9!k-4L9DskM>LHno(dWwr=!VBKZkQ1m zJRl?t)2i@COYRR17#w=_g4yzXIT9Qap$pHy05}9>b)}dVVhX`YVFDW|^=UxOGQyn^ zqpL+)jD_rYO-)W#T$3sMeBZ>1NKRwzwm)VEukKh~P#P_(aL4^al{=V*WVK4gJUxIs zLozSd=@xyCJFEWqnpehXwc%+M7a4xUWoUolKM?0o3Gvad3^CHFFDp=-Zj<3IM1lp# zS!~S5N|?W>9~SO?dmn6EYu3PawU6Zf_4NxL+4z5n#Q$v^vtv?|Pb#!9|8A&$OSr3> zRv;C`eQeDOFRa@1zVPGwn+gX_Xb)oAJ~K|x*wqZlP|+iS7m`lxC(zfajV&UA4AEyI za6C}8FJg^Ra+*-s1h@r-C7_8QPl4kOYof~s3l5e$0H$kTGdw#=V05r@1NHhE;omiS z#9B)W*Q_p*8inH}&CzHx`9rk11Z$_8rUy1XRQo(F43;|IHAx2?-smrhGzDSXw?FeN zvCF&xGV@oyN3uk(tEtiHrP87z=^Hp1`cg-bp0lLAs437PC9b?+Nwhf{DdH`{^RkX$ zQ<1+y=kjcS@x|@w4qf@cCTiQ;vnS!E`nl_Kv zPPD;jL!og(;TR?f_;!B1snE)l)frx~{!@_OWbUF9`WH`FZg? z(w_SLD-|MK9SUrHTmq`1F`N_OLDItL~>wPShLa(BqJds+MN zWiGSHMK0Y%e>$p`-@J?rKhK`d9C6hQTfAtP@S)k|GOu3SzH~_&!DQ+-mA=1rz1ih9 zUEp+I(1rk{yU#bW(=qxMS%RMkEghpKtW~`?O=TSnne@&?cs9Lh86dwHQ|TUCEVYXZ zRgJ9bx&MLFWDr)8_ukj@G`W%tI{m=?J)56K30t<3!ef$q@BQ)g14JpD0+KM~)Zj0@=#H#6Pj z#Kg_<{_nSooM5^)PZZLV@y(p4|Cyi2=*-zu0)-I%n{;!8H|!W?YFcaNEM!0?e~3AyOtmCBaW|*Hnt4`Eb^jXpYOB9TmRoU18SWccIy2i;Y=#ytw|t+wZ@yx#6+nvFZz1 zTmKeh8WSCe4>pkDiShI|Swz%NvO_B-OOso&j+vM_*bMYMidFLCx$UczWc{p=y@I)8 zljNx6MaePAJCc7$K9YPa`CLMgOQl{Gs)J3-$UtdAk)&Q3jMvx<(MP4zUk!til&Yu@ zHsL`}$=!5H#JDeN)Kp=`{2 z0`pvrycYI1OuM)srO#*S32{gC+9YO^QRxn|8W67_#Kmv~mADwCQHze$GTgI6E}b^3 zF2^^%YCz$dy@A{+S2%y#V1R8D(p*^@Z)AaOATqgu^>0ZJ`(Ws-jNwZR?5=jqSnQTs z1aF$&ZqSl{%2gJV3;BnoI;ZRwg~4IaJxs{0)`F`FVg<^^9KO9KHoXf`Jp<+H^mMD*`olVRZk8iM>sRH-WlYwvp2OO*Tmzf) zL-&%>U zu~o0Lv2(RnjgsRTqDeOdtp=Ty&D1*|=_(3jux7j7Xv!VzOxLpr)JTiF9hsSoO7|vj zk?W)o;2D-9IbNSL-!(#^$a53YLMBhP1j4pFL%FF%r-+We_1PS-mn%%AGF8t=XHHsa zei@&qVgu^?3x(IaP{=eDIM2{@#WvZftDfZUzrH01H}Z@aA21QRsjq&=$%0MifWNKtJS2i&m!i_+&kBU zmYa`>T{hOMA8}XmChyYbjd5PC(#eQCW8TzA)|ecbI@e^jMGNenBBxeiu(3LD-RiX_ zmCLV^D|w}jbSQ0kUSDEUz%_W-*u}AB2N=g_)=W`9At+Y?>)n((Rc zn()uRB*K;LL)r^W+Gc;XH;^meSe|<*#}XLTFd`O?n6%c6B4`+9WxAVXIiE|W-cq2| zDb=}lvs`9oG@KH+AV#Ov8Kj(=6j<}}+#^Pk%!-OkLT;F`xWsIzYlW+*dTO%%7f-iyL;U58$zC;E{%P_pq1XCP`vsRC4UaB4ac%y2!SjW4k z3x7TF0!zybW@d{szd?;1%{UK=Z`$K&cyzRC+0ap|$*Wy^yzzWXQ^%T7gBI&Y-&3dF zqYBOr1!+abNUzvDhh7nXy$wgk=x}3erZ$@kPVXGGX3{`+ZlhQwbzXX^yGN;(akkdw zs!@+L^xkjkUc3!?&LK0`q_9a)elh+IKpw{N$on-*G8b`xx1gC1#U%hq_@mR=s^y30FnA%RmC79Ugbz%lSl8cenVqmrdy=>0Sku`D+4a4nR z8Y^wFY}6VW8Tm|k7%nrUU$@zfN{&c_s)~Z?jIv&(aBv*MI^3+IB(A;?)K{;vGIhx7 zb=tHXVSVPpfXTo-S$p~EADM@f&D>ivADaHRnR&;Be5P7Bbz^DfrX3Z&k;A^Kl`G|( z+s6&Qd*I}&M(NUmO0u)(ls1_!(}1`h@ji2Nn0y9`ZYAg}UStu8X7=z=X4cTjI`G$X zW9<*Syq79S2BVTw?41()R-8dG?`Qmg!2x(@VIt*xWVl;e!T`y8LZ`9m)T~YC z#AnFCF}C9$*~#nv#mPTTmZmXRrzQWDwy=(^e3Yy^Wzclhk8r4m=F1cqI*d%P$P9WASs!< z3n`{0nPr){jn2%|i3GLZ(ghKh=dTLCTH3GfZ&o1N37|<`0whMN&+-ZJy;J;EEu!Wo zOBTV4eWheSVuAl4c~$a0B(a}~4i>KhQhTN!oH6@DE~0UoeJO#ZVAB1cw%On4AHUUq z&fib_6K?Jd=j!?U|JUvRwSWHB`T00C2%VPDCFxF4_?%_%`A=(!-&^r)Jq8`NUoxNn zbmp@Mh-K_VIeVkO zd05Z?P`BU7Ad4`-H0il+zEjlxU@?SpOLf~mfE|3DXYoRPF{a!B;hkP|o$!vktj&Fr zEI#ROD-*g>0K0dDcY2-|p>+u%AwuiQNC5lYCr_gGhbd%TpDiT;TbB-3FGeimaD0WB zW~t6Yv)NN|QxtJ}MIHnlM>qgm#e6R?F!?iR(wAVr+So^eR4eKgr68NBLu0F3)>UEI zdO?+N=g8KU%}wHhT(*)JAI+$(&uRRkwm#YX$l}{yBZI2PhN>=TrOS0>dh5uh%`J4n zWme4_x@_-Yy1XHIylv&8z0GZ_7VRr|TKITbezix{F>c4`{V^edl#*2Yu>jAcD*>_xw0UZHj|m{TQh>>uymZvA zJ9mv@zr6aHV9!hRlVYR6XRc0svv1!wcx|G;LUJbN2tHsQrsZ%R(a;x&C@ko4I5DL^ z5gCdhu_Ty8G7)DUOEx8&_)~$jWZYfvPR7#$z$N zAZiN%WQHm~E6J?a5{X<6a-e#8eTos1$m#gn7xP3Tw6Tka421jOsVqc)!+qQIzIfah z0E)dUy*CJ$B22xoorx1K7GR4-zloD;h55pK{*8VcxvBLd!a!jl|5L~(#2s;m5a$_& z?_CASqMtl~|J^o3o^|_k$OD1w&Tdk1VDa5|-<{mnx3>CLqCBwpi6@>&Rtueh8vO~a z_5?V$82YQP36QQ(T>luk3d?S#vRfYy35y@o$5Z|kK`!BuzXW!ZG}zhmk;_d2A`Kr) znMp$|q`P9qmjRbJeBo5Nmif%qpf3Vu5*SXXeb4X1rkJ9L?gmehPgW)%AhD-ov6SpF z-d4NP@a}Zs$eT&RAG_?88BB8FveTs`^Ofg>KNH8$@lOgp!lz98m`hgF9$LD*XvES) zQ*s}7_d4Ovb2^?*J`#_CR!;uc*NEwo_bxSf7p;lhe)!43tylfk-LQWAL+$Cetr>E` z$O>ogJH#6lzdtW*Ke>34fnuJX^L$^_{v#SDar5~M@@+v%HTVAT7%hA#hn|>1rBkLQ zHey2*CyPeu?*%(9Y$NMebX_?w+&r@NzFSsJIr79hM%g%s+(342OdPoJqE~7zQw=U! zq7t~Kxd_nz{zIECKJbT( zOtNroSv^s<;`u~9OXOsvJoRD70B4XA6uFr}WqB(9!@%OjScBN#zGo@KDc51gS&+9 zjtWE6Pi##{0E9DnZJ${s^xHNkFm8YM4ZHF{FZFfs+JWcMCR}E(0U;iME zf8c=)PYB-&f86-Mp5+tB-TMj|vios3slLOl_tP8Yc%BAC1yTg6*z6I}FczXQZcrs~ z)41h6BUm+6Sg6twr0m zxVqhHZfAQ^X0b!&YbMXWUP;F7I(~fDwSQ(lP?(0)2!B1eitS!?@Q3ZsZ`(F~#x^#q zYsu1KZA*mbZ(CMTXg1>|Z%LLROgFk$r-vwDv2+;#l*YlSCCa20t2)a*jn z^ljUo-@Z)(w(y@vOTPf-Sp$n~9(3d(lmQAZXTS^bwxB#&UC@?U(6i>#M2N94a9jFHW;IzHNF%Qy_Id$F~S6V`zo1Ek--ejJ$y~= zl)^NYdlE@!<^Ew;NE1iZMJD6GYvunuF1z#Z<;ift+rrbP56o?u_9B0wy^z`chEZkJ zWCp5zO{$EKNcp<$?+6ojXS5HfG8o9tv{JPyOcn`OSv_od&{ftPm>^R#6~fjDgRY)4 z5=jbYII9fC+6zY~KM}6;_z}^>A0Ug!+`IKwEBipLaK+(c`Y4*nq$|)}_-`r}{`7<5L17G_~nA^!5?hu#w&;pC;s! z%KG>YDAwXk(5MflL<$+BCJ6M5N`m&I-NQ!V3*-dSBu(0~iT!aLV^<_43OmEIVv%6f zb|QUdj|7WOt#R{2_Z-{JQ(4K>n{9L46E~Cf^tefY9L$iLO!A~7wF&nj;2Sh`W+Jr& zt|Nikw@liwVUjR$v)I=W@`?GS7gC37t?~9owXP=$= zUSLg;!Djxew+?}nGWjLw1N?Lv)JbeTaB!dG;YrP$}*NeH0;G zY$mcP)c`$@i<^)K(xIQ65T8#1xr*{v! z1UTbyKuB01F8Yl%7UZsP6mc-UY*u3I5$qzOQ?N9KQW}TTSDH>;g{3Bx21Hw8UpYVo z*il3J#Y%9qynht7UZ3r<^66U^{rxWB0^FVc&xIGR+g0dy$h>Pe65H!`t;0V*bG`7u zeJ^*}(z4Q2o~`%nCwa3hCQr^Q=lOt0Q@Uwch9bx8k-KK8T%ToHwqcVTDCmcSgp<)f1V?VP`jMSVE~qE1)+J>WULJObr@?gQ_ROngxBrFCh)o2 zy~1%)V279fG}cKT_j>ZNG+~NY_`*vHn1Noh-%AW$e0v7`zd|A5mLo zEcH^zz~LAo#t6)WfJf8vVgUTl?ntd87#tjC#Yib)LS!$kXTp{>cK%js7p-X}MJ(M* zr$A6%(66a)3!!;dldMSG$C#p+acE~i+Gq4%QK+K@5*s}U>^^#;Q7W`rEzu~fBwMA{ zAaoLWOc4mHMf%s%pP7;6j4>D(?O3Oikt=LAg`7B#Ivgq`W3ezw)g+sZQEMy~jk*)t zTB*WpR!FsEqwv1PqLk?wqmj|el#@&*l^ko>maC?s%xuC2m=@IJ(r0x#a1;@(R%g~t z(`xlrJyENP-m3eH*61`6sZ*a`M)k~94kWYzHrc%f>WPW13La{!fXnOS}h4RH$75Fee{qA#>>htf^ ze9yNU&9^<8v`@ZALb>lhktzf$vq0GLy-a2No~$#fh6%af%2lRs$r~nBx*+}9V)>e! z0$Y31zDT`x6`igr*9WCqHhDgi(zhM|VSFsc#L^!xw5IM`IM>AfiQX%-pnp^S z1I~+7Xb83O0^UaLuQcAEl0ip?X%~-;1tbeCqCjmJ`A{?zHY3Oobz%91Z5NTN zRv;rv_@i!^xlRGi1!PwOcDF5LwNfoSrzX>Auvt<9BCg`fifg=x;wI9%!i#F(z3aMh zI*pz1N=`9plvcr%#2N#3jYgGbAvU#9L1W?7F~Lx|>K#!{{&&0^lZ8?(qxGZ381f)$m_$lG7LE%)mCISb zDA@VY+H7(3H(Pm5(}Dd784K2C!n29}2bzR8I;KH8#I}^VYUx!BPhciz_-P%#qs7?7 zyyQIcq1maI+u006dNMl^qS$P9S}c6Jg7GEaSEPZ(&S@qO&+GS{rJjGp?|Xg<|M$Zi zP)R+&2=evQZ8p^iP)*PZa2*tYa1cC&CiXXXNjwnzY~dfVb;xiT2^EU8Z@-zYsf6fxh-}X^3wB(s}N@Qn~%UHdL-S{=+V}-7-IDAxNm~gPu=v81nMvDg1B;KjO??=_`wbqlQfI$ z=m6RPY~ulpnf_XS`@Q%nIXa+;6kmW*6vLkh^!k|3nO^akNhE*`r2pBf|2p&~ko1Sy zHcx)_dsoXX(-On18Art&Z5+}DocTk3Yy3(iFoL}<+~RVKSg>G(!&OUKfiD!C2q+Ad z(02tv`kXnU99d;2{m!>Vfxc8;LWWAJ08!ls9&P}+^caHh722$Nk!mH3B1-*AOK<>m z?caQ}1k#P1Q>$)6S`{QwxlK(H%EJ9*Qd|33GsccCbC$9lIAyOKrwr;ATHVYv{|$Y;Rm8X63pN8$jCpOI+oxJ zNO_s;rq5559Yl$~|BLq@gUw+4?|iZv8ZnBo)<*s12th>1iVsu*V!k1m7Z8#N8w12! z2nf)LX;{PH7FM~J%7Xs^w03myZN{9+0ZB+h(%Hc;tWWI zl+bppPAW6SXrMKf;V}$rNd{)){$@V@tr=75UbwlSt=(NWXZo_vF)reAj$N~M*ujHh9`_x=rpQ-{-M4Ik4nZTw?@?e*h}{#zFBSP3o42n)J{asrs(LFZ%0E*$JL zG(%@I@Igo>_?}Z4^kB(I8NjW7W5x>)2oL@7k8Cm4z7Za1C3;L=UtUgzCU50l`J?a< z(IjtWi!*v&vE*8MUdhN{i?MonZtQu7>^S`XMGrsx@Wl7YEKp8xrTz z6;Va3J^UL|npH7Eg-lvadfse|QD-IY2WzL#|5^ghA= zRpP@NJPU3zQXs#CGPI=EP?LW+ifCKuiAz5cx`i&G`=d*rB5lXs72X9QftY1hc=z37 zr0pptaUb1z=|?1f-(SeGFVjxu30?oB90ZiP;Gd*3?_}DS0$LFvgP7O;ji#K29$#vV zMT+n>aw3pK3}45nM1$a=_tVe~YWk&tcslS@0767pC_@F}-NjJ%d=6Sqv9-u6w;6kJ zI?U~!mD_GI zrDd24eB*`>v|6eL+qv}YqAaaOD^q6X4J&HQDFkN{`<}4y=Oe=5Pq#9=-XgH&F!JJ= ztM=@?ZD1skgT$G;n$V2%{GJL^-2E#J#Adjc)h9mL3 zG_%j3kFHy_Zt<)U)dqtGyrK1xw&t0$Hw{Ew_w;{W`y**j$vAg=Ap6wZU2ps}+r4l);1n6p*cyMK?n!h3(kT1re7a1HgxN zOS%`!2u^_0V8HCH7A_5dMHjn8+$9c((L=~5kX=_stB3sMb4e$spIYv+jtKbMP2O^Axj#fN zQdajm!W%RfpA`OtIGI14y!hgiqzZ8>RVN?(l@DZQz4X;X8AXxuJ90;>8H2m3#CMon zf7n-6=AOQIf$*=4L$89EUOhVZj`9dIzAbxncH4y3n;VQ@DV1Lt8*Xl$AQnw*xw+B! zrBeB&vGL{>CRER;MrR)^%P#XBdNp~MF!Qjlq{=;O!Q$!evNB)DhaCsAN2?fIIw=wF z4EK2UZkheRhRmn_$b{(2k|Ex@92Vm_l4TUx7=%%bGAgmXzt&h(>c=oj4VE?wmg2(8 z6vIJBL17emi$%E9R7~yQF+Y`acpL-je~h}tQ9mv7KvScGaIpmtc1qR+=TXWLQ+j?1 zQ>JO+ys0w-&8@A0&}~D@BUPhUR_2DXmSi@zMAN~?N9~>Udk|+vgDK(!@a_< zn8RMdRRsvEhZbi{D+|Si=L-iFMVgA3>HYD^C+lnDWap@n9mT;5J)WhbBeQj^p)qP_ zgER9Q{Q9E}aV?)_&z0*I4znXzdx|SYHs{-Hg~IBHVvVK!17=0L*`8Lg0?ZF@1xqVK zcIIvHsssbk(h(_F4Rz}rOpWD@7>ABx9HQ+@ZJ6_cqC!>(;Fznm~?z$GXgL-oVkL2j&So2drIK_i#h)pvg~O(b+zg zJp3NVy~i;V2hOVLhV6dc+F8huld$0E^E{RH)lUM{PH6OJx}J1W2Q{X@QqL2 zFz)_8g)^%<$5xWbpz?UKrPQCb?nzF#W;3TSJ8y_22yAp-ojCL;TroOY-qyf4f)92XSRi(|b66 zrYxOp&NORH7i?ekx4jegVjeX1&VzF>DN>mTAlVqD6+w6MB26#tbd(FolJcWufa5cS z>^@XlqPR^8DS;6Q3+mNHZ^H>-`-4UoMPUJ#9GnHy6SyGXHu=mIdTWjPa*|V3AG4HJ3~id$R>6;G(3YqP&y%Gu%+Fb> zGpAe9V63@*fH|0-&Do_>j8+rRzyy~E0zzkLFf;67tRTz;_2CmWtU0TJL#p6>0>?#4 z?y7;j`IN{J?t`p6SmckT-zXjS#L=p6wUqhwVuH#Xh?i(gKt3Cm#R8O3gfh!f^oos2 zrh$-Nlvu4yVVOkO{5x!3g9~4gBV)Of)g*C2r zMRJhv-qWP@nfpljac0q_D`L;>YNQozA?|}W5%*o3vOQ7^Dmh`YJ2%he&dViVoL_J! zcfIh_-l5GbtKuuYv6wW!9)}Yb|m0ugvGzycA?L2*4SP^8I3~54# z8R0v7<|&B>zJMdbTQ&|D4>FPS_e{H4o0Vx|yQxYle)G5{{{yVn>E~QkOw>lN+Ivk9 zX7T{8_PcKKE8$I}N2@Sdh0Gw!`laA9ci6mXi=tVgk#3AQIl5G-tQj)bOg3r8*Tz#J7ke5L0 z?q5lGlmkagGE?7=wLuEP~&ZPM37w`8CAzN_XVmpO<@IuHBiDTcP(6q6sD^hBU}w zp^ry09rl7F`8juH+Z<_Gr8?}z7$w&#bXEBQyFLF%e)hp^ha)4WOy|dePUdkiHxR#Z zc(KEQQ|27XaX9>W71)`fuPO-G6EazrBhAYxm6lcHVvCaFlonyzb}KShdeWS^GFi6W z>qWj$+v;*QkIi>QGQxJLl5>mua-CimBUM^17rK%22dq>iemPcbA$lNoy5ab+UDh*v z6y_ZjUpND?p}ClcH_ zdj#NC&r-(qRujj-)L0Ni`$nvKX*z8~%Cm=&9P?-po2BU}$C$`N6XHv`Zm_cn-#^X> zdnT;M>elrW$ZUqvz0p-+4;%`!ComFP*3LK*XYAmb?Pvz*-?1Tw<_kfN2U!( zdSRGTW3;2Egl93hSxoE)1dgRy(FT8I(^Ht3Vtc)E| z^A!U6$c6nyrR06)Zs ziUx&Rmm^T8VOFOjD%|SgL?lw!!R29Q2AB&S^KZ*lnjIQdwlQPlNC*39{SnO>tAy)OcE{)+om-6iTPEL-~%%uIf-K6)weiMLO^;)a=};y~pS_ z;@|G^w5k%-oXBf_eZ;KHy=}guP|0VG+?b&vcjtf8h!e(ddRU}>rPqM16TGkE;wDog z$?ZK5XLfy|pi6~V^0;{JuHH)-jRX3wk2^}?RK>RCfXR=d-vxQr$DC&ZA^_RT5JVmd z+xTEiDg!J5O=OGlCK&>%!=@lJ1;&lE1;Rf5mo^}7!Oodq)?T#hi>UB{@Imy8T^HAU zIdi9%G+n-Y#rG?gUrw5s*Is)~xQ|Qxih_H3&`YP;aVJQF`dG`l{rlIo98(KVoEXQR zerZdl@aBMUcmT=HL{9+CKUIA&Hl?_rYB8JAj3Ly*a5Hkx9i^i~>J6tRN|LX4la1==-1!0r0DJd9=+qOLjlyVJGAKunhY&d(CkV{CoLNw7ts;pmj zP@!L<(6g&MLavP)U7_Uva0t0fqnyo<8A^?zq-98JMKD;=Is}e|F=wwj5~sw8>FXAK zC1T&D3~m&?1N4Nbt(}rP^SvYXBXKpfApCF4wY4?JpOK^&lPiH*cg zoSBGQuJVG`LtuN~I4s2Zcqux^59Fj|jUSB6HUj z+|soRkmtE5U;GKVI>dE0&js!oRSMRLHI9&HXqBsj>^RC*-Oip26|6TKW;LM>8H( zAhwF4+eIlyWIqsvBr49F<$3b*kbMBUz~53EaL|YkmCB5Cric8^!bT9L(REPPLZAZ= zl~P$r8?H z-6K}58ZmO^%8|Xl!jH@iV+J=)NKUq8SP`wt5x10eILA}Qd{(N`+tTbiX9@o}yu_bg zP`rdR!OBU5dzMBD(gRBm6W6Sr!4emvWSNHt&73(X*{pNHTggeLLzdi&Hlw~;9lROn zRbm=3gDFO1?=1)pBt98+!J62_)lAyeS0_)8CQWZaU>+(w26mXG3%H@eQ1Sr%pOg!% z>-0x&y~W+xqY{SV_afp;_1|$n6aG#OX3$Xz5~oaxmPKoe8ZayXUU(XG zgcIW#L)gYdMBQAl9n%-V;w{AJ3&Wd0?m86FrVF%JyrXXv!ODbFk&IgT+Co_Raz=@^luG zl`jpIyOSM!Wks2Ak=&I2sm_2`6W8-T#e*LuCA`ND|89W2}>eQN{Ai__(b zN!dD!TB~e+u*sxSC_^V>y6{*g!x3qDsF7*)7y%3vj+VY@)>@Rr(rSrVa)9iscgd{G z@R?@ASZ1`}l`~PN^c$0Zd_HVew&>*GWwjP$k{Nf^OHBsbyA(S`^V3jYPC|TlXEVY1 zA+wg@J>u<&5*{5CsHE5bKb2n*q)Yi65ERg#%E1=}w2*r9X)?HEf|tN&-tRvIJUF_g z@PVs%#DXLixBUdvEI~&S5G3-(T zD@77y^%mtWL8W?7*dUY%8y-}t47))p%rQ=edtA9&bB#GYH#gn9E`mS1j2dO@*s-lj zjd2&z%jZnXt*Ob~WmGG-?AWnIsYanrv2XwWeF|Ffv6o+dj8>EYO-^k9kbuRn?yN_u z7QW&U@UP61T!4>LL~HYZwY3EHtn_P|v%FMu$N9h0!`j$jEhscrM29 zVaI8UomKda0R)kZUWpr~co{h8eH4?ZP1exW)`kZ`kSGzjlFhI1x8nPu_w%h*mQoE|gD z5mKV}3pYIX6jGVG-#sZDB3BAWlO|yaa~&H_b_-*Lbxa`xAOLac9Zs__3q2inXOVx4 z=1;OiDyR`9R|zceAisvQkVi0xPsRnsgg~ZZP!^i}G$9Ax00w+2CPIsmS&I=?LBTIn ztbuJP2=$FEj=_Rde10#MJ#v}01c|X&^{Gu2s<`kigRGdkn+?vDgD$?8@WI<=-^T12 z(00LI5HuHts=}k2thVMwoAxnR6y+A>gIkw$C+e)<-{XIS*If@=@{eM7l4FU?B-<4r zsE@4%7C|#?g3vs!X_ZG{n2pKx%qG2S<)oQ|Yypcm-KV-LgRGuDx6zSdvHFNZenV;U zaHqAIed@G$GG6SP`ZH~Vq-U_v1;Cv<41SGGlAYiQI3oFr*v?T)EJ~S&ATx#NHLzEP*GNy9vh9j>s3MPZ zoqrnuaNxbAZsP3mAY~@8V%+}O`=va=sA;u9B*0Z*Y^Q7=dTK3%j}vblmxZGT&wW<( zP072=eocYdU?o@7!2HBY6*4ztRu|HexYuNNn;oadkI5}d9~kB`fJ9(O39<_m5Oc`p zDJjq@2nl$+vXG~FuiR>KDGZroGVC&sH66JRM|$VGWgeu|G0Ej}iz$bZv)0%%vPG=Z z;dLv#uF0`%f7a!|m>czF5Fm?Lt?gxn+nSc?a#&nSw>2+1u*~@kr{VI6Ic#$m7hrzJ z#pEH+;B8u&&0r{FP0A9a2HIDa6J>3lv|uclX1(C*)7L(9&4%1a?$V`LY`Es3YfoP- zmaWc<6SdKSCQz@@5X&Sf0Xdjl*dwx(_(6h7l5EGfLojq9v z16HnZ%493dj1Kj@NGXsPF27^ftXaG6SiUet_`Gn@b(c+^eA#u27VhA*{XZFzPa!p) zC=uI0GxFAhQDG{$HI^XH_GOam@vWfOfiV@`&l)s~D?BAi0HPB@Br%TH{ z%}S$IZ*k=YW10Rey+*3Gnq9e>@#?JBU|poJA=GM~v13N^5k{9ecE`pm3Pa4F=tbws z$>VrVOl+KOWklVcHTukbRZ zeT4?U1y>Ja7>fEWbdD0YWM_0iaR+w#Ea+YIzf6qN!3ojRz*+{S6KABWl#maUIB?oy zm_=QRE*9NbVi_#+tXPQje&W8q+l0JMQXLqFK_teQT8RpD=q~jV;C{r;jeST&adsa< ztqpz60ptOW$Ovgc^=SpFRBWB-s&RQtU31ed+qaYIX-{O19FawQ+3mw~giq*_yfiMi z$67zBe9{)j#g3-soeSrVYGwAQ3~qbao~2mdHUgP4xVH9J7YOgZ_12ziujSuJ^{qvY znB#5J5;NmL>NlG$o;6D0D0BQH~l^nNJrrjf#bBv)p?T)Hsp55v&*4Z-#)Lma#A$;nvI1P1Rl2Y4@ zP4VlBAiw|ZZ@aI(R`|T0`C;bz^%=m5WRzrXS{3jY75Trg$1l9l=LqHm9ns8ClC5Rrv;FdaB9So~qFN z0^zGS@TaPZ=)l)b9(^?VhS_TdwG|oP(Lr?M#`TmDT{(_RzW!ls*svILTXl7QenG)B zq8)8Rm=9B3T~R^S=HibPf2K^y&3%wuOlu}PXaW6GQ6XGZSvgKKa~dZfW4E8SWhxXI zp3*#@Wg5|WVV%LY&l^?vbylTpDnM19O+-%;Zz@H{&p0b3 zAcvO4j2ak9Q4X3Y`hz0q?x`Iy68ybqqK{tuTP)Wo$>Or!Lo~~Oc?i)% zC^|&6DxniO22I4|x8ia(^8PtfF||eXj^|3q_7Pxm#$X(uFIg_RTyjHd9)=?)3PF(f z(?##Ri;0;|yKt;w-lY;g^mcLDg?l6BkLrMXO@$gp(c7xQ(n%*^489F$tSGHyZN|HMya|=>_TPY;vhilU|@yZrMf{5{wk(y;`oEC@uWF?%@{HqhHr-n$!0VVM z+)MuY-rDk#vV!CVj@_!VI`Sua`&zlKgs zzjMkwWJF3MzmM8Y!+ZoHIz%5j%OGz<5~o3V#EB51u8BD_x48?vyjiPE@!lJtKRG19*OToa}i_F({U^HbTJTQ#EcYa|Cz?d|*O>*h^7vy#plPJ@pS2 z`(SsY_Kq}2Fjh)<6sI4s*K zc;--D6Nze#T}(GEPKu}e59{o|S0DsYu@iNAT1Ko{F@k+my!`FpP!8TM=6dMGv*n6t zKZ@L1|A|gpFb{z@wzb11i+_`MsF`gwx>G4_>yW{1xGIqJJr4#H{u*{Yw4j zL08=W$o9r76w*~vWlw*I29VOfz;Tdc3nD{v@ZG%n645JMS%dNx==DuGMUU**{Y+tY zlT4vtbAAiy(I2a)g=QlWpMk36c!(OzwSa6;@CRNWW;pt(8Zj(dZPc2A7Y_^#OGnmX ze64zk59vFBNujC_UL|bhuzFG86eY?BowtO2dETVjwNtC-P3i0!#gsH(aK#X*NjAB_ z&6n(-bkqG?{=Rk0B_SAe6#Pms=rgN%N4mRWY<(e^(BJ7pi=Vt7@gG^>+f&Xwy;aP0 zC+4stW62%NPxIGS&%bTT;4Vuy<)7h#o|C*a7=7tyNjwo`#?MKW&3=Dk z&ofNCJJ~Ij92I_;`2K8E{IgQ53rZl#OHr||ST_5ENvGms-R{)=NCk|kdXd9e93drr zHffm4C_3IM0hW!4QoJtG!%2rV&B+rEZ=JGc{X-L&^_4x3g)bgKIN`g$Uhw3y3Rz=W zjV?>;r~}YkDw)_+J2rXw1>=uwNQ`6}N>6{^GT%DzFT%GIZ+>|t9|>m!>nBzQXwV=X z8&d6(gPC}pWtVK(e2JU-hR0ull&yfYYVx(IZavVo)GhfG@Kmq&Zt@L=}9o?bIERr zM8q~Er0A$PQV$;+I3q-G9X{?rF<_p^kAe5j89~yYF<1C-A2LWBJ4U9w{y598o_`=I zd7Vr-#$1$qZ~khOlAE!Wl(?YN#z*t9(AmulrYq#NHF|@EJP1+~@fl7Ctrmk=tFKb3P8bFPg6Bg2<;F-l zsRRi$n+>`vhP!+za>vu2DUO3MJ0eWNCWTNB)tB~Vnj8d!JP4xTF+~5Q&O$%Hx3W+; zO6LG%P*QqJ0zoq1_|D2XLt7%{-Xc|c<=EBjo%hWA%f9=Em$^pjJY=)*^EKaHGUn>% z=8U;&7O>OV70%8}hc64&wvQRxT&800T{Lu5AyHes+(xI{)?C!Y#-)BwmJ0}&uXg+~ zSUS0F!?26o!{?06T=YO^*B6s(qkA#}WY3MTHP3l*_k>W*)ae&3+fn-bl(y`u^fX&u z<(wwHVc`KFbF)>hJbqdctP}NU0y@5-wcsD4e4&^F@F|9oj~Pz}`PpxU2rYWUsH}@8 zr4yc&P6{+23-O_r)R-UZn<9H7a37GrO8$v9xyC1V#dRBS#IJz3m%(jR#jy$9k*=Hf!T|f=ga-ptU#=+C41hU z+5HhvEe*4k7L0gU< z-LmYyTOKo(lO-fwNS`*x!t+PBR8`-jQ(AQvzww@lM~R$N2|o$jg`b8s)d~BJzGrMb zcOZ8fGOsP2ap?)_C58|7!BOvtYZ9NCsK(DYLK02sr_+uKKOVjMi&3@LlEju-JO4!F zN9{t7twgKx5N`6OEk}uXUYu#l-L+GN9Or>|5Zt+x$YPJcYYoU^NysfM2BcG*8%2%) zih4)`CSeHeJ8+l6E#BvEHL=hdC`lD87W!(u5IxFe&=$M}!VMgK$4v zZ6<54|CCF4Og)2mzpZDk&Cd_wLtZZA4SnP`ClhA3+sq`)VgG<5$oX=v#yq9;TKMx=tCAM2I~GZ#u^MtVoqogRD$=|0ocV z+7kNGQM;1HJW!btygHce`9~swWPKnK2{2Cvh}_nbP1o5g#tLuWeZO%0UK{%+E$CT3 zmW1!#^7TEl$+Adbvtjc)!mGD`FU*_v1l_v@+ob4@@5s(+M*|V&A5F!@O~s=}kBs;O zkt^@GS9s(8zV%u6enqzUBcn#$F1-5gW}>+ z{=Y)x+GcG=>T?p~iSzMj08B+}@Hl2jSut@lCJb?2!6wF0DkmE-%BIMpFt&QRSOf<^ z%N0du%sm#^E#Q+vSQed?&?qsu4#bIvo>X==m^KBYHd$>o2%SZ3mIA05`dx)X40~kh zid#eF!WCXNn4!-03$N@qrs=BI3@J33ht1lOp|z!JLgn=ybMcLi%AfZA4#=WO=YtkscYbJ}JkA2&$#8x~$YW6;#W z^Mxi|&7_I(T|&>33$x1!U=mcf$NVSCMNUMBQ~q@11)+^6c3nuTetf2)!4PwQ@IUS; zg%Od?oFQL2Bw8pxc!Mqm%oRSB~Nx25FwxneG9=;!SH-6b@<#Tz-B*%fqieUoBS~nc7-Tr;%4Z_xfwkRm-(n z-j`m7XnjT1v+PT!(8K8;$ORb4Iw2Q$z~v>P0iox@l>tT92hpr|gMR72PZ_{E)o1vG zZV1O4Ml_0MrW@=DG3R2}V&O}11&aD>7oXfp5?fDREEG}=y$kBTelbviSV4Ary{OE8 zxwz|eg0At<&9|N;gL|&RQARD>Eh_bruEp$Ptl>7rcPPp*I(Ypl!bL>Y(_8G*#d*;o z0=qB@DX}!}t8dq@Z3R)C4$gqLh&4q^$NAPhKFwu+(e8F*;S&BIbMGA(Rh9OS&$(q< zrq^WBW|B;LPi7_wB$q3&bd_T{gRFQ1UAN)u#frYqvGEop0K|`Qn+6J~GU4=ZnFsa`Ahl z5BGe-Lele6Kk0e+E3D(@9AD8MUUB^R3ch*8arP3I(S94ae-*3X?!CPIICTdE`2!1= zI>B|v8?;LvgS^b8#r;O(h)rm03&G(1)ea|g95kK-&K=QzzH9i>HDWG%Hyi>)4a zig4Ny$Deb=#XDYQDQ^iWZXmAhummmaW*hDOt=p@4&K}pE!8S|BZ;_6(S+?xaOD z(fi@#`C!r=EbG%xg|nyB{7Or7&%4s^@m4dV*KcEAWshY3?>F(xrF~!2N)0U7-h32) zLS^BG%-?eSgX;&1+8`g=B|L$EJzN4jcn5i@?&% zY_47#>vQ7I7ppc%2bj-gG)d13$?a#^6zQ;qPY{rr5%Cf{dzFoQNz1Y3GiNMqBh+Hu z;MqtCbv7*Bn!tk61A-aHpHz!%RV}Nz_v05%YWV=boGiwZ%oroRc8FDc`-xV%(El~g z(DGRhFhNhV67x>!i;r{Jwl)q;;Y5qUpH7g9kbLQH6r)3nx@9;)2rArN}8UHPa-0B!ySb7ht!C3u9Fg_(_==TXOqv~R5NyQ^t5z+zp-osSJBp!P2(IZ#?M?ORUt9F zqqt^-`z&i%aQmi5I%ov)VEse(ktK>w?u;;Q&==I)9)ve{u*3^`Ewe51cAf-YxWFiR z?lf}tBzMrQnSOBN+B2s=-@Eto(`O=U#Dgu2`{uxbZx|>2&-!zR);#!f%l`c>FF&|u z_H~bref`9VA49*}d;2Gk9$B*Ht>teWJMp@(s!dxyZtvc4<-&z^bLO<&TVBIQ2kqQB zsGZNrO`SI{h2JjRcCfa6cuDb$xnQP=pFV~;dYsHnQoIU31sWu@Ov8wKi83n+n9i?eKSF) z7b41MB`EbeSXplb7UwQ_e%+xu2G1`Q*b;<<%1d|{P=uHJ>M!6o-QB*FvZwnOt^zpo zm%p^X#2Na9BisSni(vSleGw-j&jK`YFoa|WQNYxZN}e->L6Q%Xk%FEN=e$rpW)l;q zR<&PAj^(_jdcgC8fY;O36>5 zuhEyEl9KN$n3$iEPu~dz2>X63?W#ZN#Nee@Zdy7x?TTyS`l(NCP@b0Ekd~zbYP7Sc zq&i#g%1zEM(6AWfjSI_TL`&aWx*(4BXj2@87Zn}%V_J@Z@9$39(*32cVZXbT&*XQq=_WnrGo1is0drp`BzHakp zTUq?MRqr0&wRy|2u`@QWpOiGy>PWW!{;rC-mBm`KGp@&@6HiG(IseR?FYi9|R%raH z&6`$@4?T6qp=TQ^g+#m46dP!qx9q(wXPIU6_WSPNKKlCUlOp~khi#DKuJis}zte1w z?^WOSqCe5x!P7=S`r@J2$$@r`S{;r!q(*>)4`~YEazlRhgx3Mdo8<0dp<_+Fsz#Kt z_rdjbk~*m1$*EnI&yxgXsCNm7)gi@2gw!EQA^H_m1r2lfH{{hD-nh1Jkqk1HznuK z%+D%3mHG;ngFxtr^lpW|(j&bh{lSKvIN+aLL_iX2`s*BjGQUhQTfI~(R4ShxCK$V! z5nKu}iwfTe7FIS0=r9@c5R%E*SfvF?g?CLCz2QU91%uGim-axCBRl{)k%TaKFKd!` zF5J{a4H0Q#Dvr~S>N8oBpqbof6fi~b7lVJ^AR1$=Hn%Y?->x^t7-Ecidw!bHZ3A$H zXyEA(1ZdyA`?~i1*X`CN<_`^web2?c^tQEknm0FTUe9?+x!$zi*0*2M#J@MJdQ7$j zp7&u2B??ElVu91zInEAv6Pu1l8aJQTqjhMIQ9CX*1t!KFJCI@nmQEVq?`b8rpDylz7o=iqSf$|tjbu)7}YtDLD7Ejya0GU zV$mpFH`MN#3?OoNJKc5d+Nhy!!*er#^_|5qcyQmQ1^)O;s@`4d@Bss2uYV#e)BQnP zrsgJcs-+`8NkXhidTi9^=(EHgKb>~|*V2u*-tzi|ca}ctmR?D9*sOaBa-oP9BT$cD zse5OCn|W&608PvnM;5-?ckYlcHpFLiYRKdB7J%Ny7bm(Rc}ec1gxN~~)Q>smM0LF9 zgJ|2Xg~{GzNOYuthX(&jwY$Q9sNjdv0v>lT&4fPqCV0sg6`D182En{w5;RFLb?_k> zd;+ZoOBIQES9+Xu#@BNlv!ocg{_NkS*1w;#b{>gkoq$(7Tqiv|Z%4Y(98 zsE?0zTZEY8)Fg)^DJ|I`m}1@W@KX2SdWO{CV1BTKW}q+GCFl!%JG)=W97VEgM2^Ld zm%XQa1ak+AD8dpmpkE8c!`M%J4^n}^7u|=R1?6!JyphPN;8U1q^rR|`OqZx)MS$Su zqq}USw&<;*g)MfaihW*Gr?{Lc>fL2FE@P&2%R+6cJuhbcZ`7%|DdI9|%uK1JYW>0? zX=y_iuCHp5IF(w*3(@<5IzN`P#XDJCbh^U>VCXLwrLq&d4t{KPaAKA;jC z1k1zBc5usAyUq69(w}W)EmF>s`OFS`D4{s2Fz5&cL(z7U!pX$J#3vhq-3;~(QX-Zp z&!)17&7O4m2GWML;|{+2=XVc|!)o~(ce1roo2;~)N#-KOJSF07OHH(usipOIzOh_6 znoe5F*27*szF=xYuIgWVC$+ixY8MT4ZALO~F7WmDuJPKA!`V;#JQFUpH$rjyuxmqIn z72Xb(Hq(|%hhMvP1<{GD2j65lZc}X^WQS>M>i)LmcO}PQ&LxD6|DUjgNL{UUQ^WNkWN@KtpDqN z`SmMw20ZYUXD_Q#Sskf!0y_TQfGeoPq z>GQ2C{xC-FKi%HE)Fb7|-SS2Rg5Lch{@Wv;9OIekjljoS(U5#I8W0;0N)Y&1XzD&9 zCw(7zQfl`ket1ef^XMllxBhvbSs8=j?nm{Xq+5y}B^`03$F<%kFYa%5Cnmkks{N~W zOBdTUFy$*-q|?}fHdJ@mH~OOu$E#-jlQu-3`KN@plQ2Q2THMi;a^I6#y%1no(fhjk zoCRGj(!FWWgkI?%Pkj39^6jWNyj;6c*Mk>taK|y@vn|i=e)zSHQK>=~MBK9GndQ?D z9GJfR8NOWUeDcpLsTtbtaj88%Wz8V-&uO;x8J2SQbIhEWvSzY88voSM4S@}fNwWMt z)_h-idso+!!uJtYfXt`J_O~987_OW%6&N9s>S$|C9Jtlu~9({L*PL~fNv}4ef z^XZ@y%JviQ{_}bDy&ZZFE}+{v_{#Zp&8X$g*yy<7cN+=;dy~DZVZiF7g4(cvyPx_~y^H#}H*XLhtm*c;z8phrsx{ zQlIh4j*FLPB7RM*^vuWiNq^pLH}C#x%Ry#)*rL3)W8;-`UbEX@Q!X_Am|UB-j@Khk zv3NJIj%p&pT4;xBh;qt^;RM%I&AO3GHE3U22e$=ns_cj%hn01_C3ok{s+kYu^$!7w zl&9A}BYh~}anmn7BTIiqug}B5ZQ;vR;*fa@mr!;*(?U(rf_dm+mfh7p%Eo7uyR?7z zvw2m1H>4j@c*suvj3!LP0VQ#r4=b~a@+0B~9UNJ-i#;R~Lo<8yPI?Az8qHK4Tv+st ztL_N`8xbOqh+zXIMpXWGb!V6j1eHRe<@2^)=KjFX!BXGF^>Kj?u25N_0>tCXV<)X^ zO%GhspM|MB>b@U_R0-S%HVAh#mR>$+ycf4%;*#m#q`33#W=? z?X?B@H$4xCoYk_RpnUU`TL<)GeBamvb*#p2)@qA;iz#(wlMH(EqIKWgKW*Cm-$+=k z8vNs7kagyMebuVhrEl)|^>Jy^wt1^w=ZYJ3qTZL25va=By=d-e?YLep-sp5}(>Uw( z8f|?zP^ggxcU%Okb#EN|X5cJw23)H~w$Gh`T9Y zAg^Gixt+F_3Es{UCm&W8^^%h_0A0G4U3N#2#!e1J&ZxY=-~;v^1IIxuY&UO`&UwJs z;W*-?^Z-654k1erxi@u4Fes4L9|)l@eMSiOT$nW(?RKMd#BOXh+NC4(gEh%NqTT_e zOjS3NR6`o4H`r%-C0w6wd+fHs4*RB&p8{+l(gA`m-SzXcmFq^EO9y;keA9J->C2~0 z>Xm7&#Gkck03~FhJ{ZybL#|(miVy%h>qk8iVFEI$guFx@s^uYuKmkf!N9r&c&sQT- zj9M~|yTZZx}y8gyH)N(b4@DhS1b^d44y`QRn<_n zfF!4t*gBF0(RdPw?{9njU5mxl*5a~Q-hI3ceAy3j!XsQ6wEnrx?U4;ni?5qAGtIAy zPjBEOo1bfKmh&62^8|-Pe`wSz?k$h)U%G#1vLd>FS0>P3e3s9Zyq@7Gta5UZg`>^C z@K{PZRQ3`*R*hcyufH$L8 zLw*|>7i+ah1I23a;4R*&YEg6aEXF2u5B)oTYjT2 za0|;E3Fb>GerEe&rsw*!eIA!={D}XOZ$H(STg{mh)Y6a8GU2(<&KQ$~TZL$a?il3o z!n+E092u9cL>m{5D_(H1su7pe+Ix_nSBXw7>GghJ^m^0qi=Q%6$xv*tMQB`tJD3)N8+yPg z-&T!E;||(XH4-QzkSzrTWgE%+E{s+A^)?1=cFI`XAN;E_|KkYg{No_(TCx5WiGHY^@>D%GUh&e(OMBfHdBWdLMUU`o%CX-w1zu%hr4?s^+0%7leI z`^EwpJX;6tM6OXxNKfGgn{--3V?eKA4x1-6!EN$+;$!sM1fyH}yKY#L5TD@i4oZzP z_DV8}d|8RPf08LX#_6&oU3@WVn9gTUh|f%{GsdO*%_Sj0_pGUhJuNTa6UTp`weq~t znwiUDrIxSnz4z;TgL7sxjXrUGvQ7}CAGN%|y~7D=bxg_@>2^z2x!DFJbg}nKynhpO z-+O{N5BhlCT5I-{l|WCg(R0A#F(Cb_U6@lY7?LarNR7z;E0zluo zvpL(OOXe(wH~;Guu1RcMm7U((%Iim!1UGEA_%*sXyQ@|dN}S!wjqx=)Ba+6>7sZh& z-O56(S(_K1TAbsy_n$p`@9Yof=k@AYug;v``cX`>+gi4`562Y%%sQ)(;|~sZ*^*=Q zI#*(%PH%FU619c|yfbq>r|%s|&#CfR{rWhY2=soSo5ZLyd9}d#lG7HItqoY*iOge( zHSs1cKS8kNR|M*fTDSn4__fkMM%<*g^QKs{$&?UlEnQo_DAnsj2CXa+m=3`5#}#9> z=~i!bW>%n&jw^~aqZcI@bO{!lQKwHxa%%ZU663tn{MRSig%#PGD~w)~DLma`*0ZH+ z__{4c)4XwsHo=~F{q|&2#pZ0a*)pxhTC--MfVLbn7odwf?KX|pv9Tw|Z9KMY`LScm zmr3d9iSa8is$%$ly`B{s8`12J5yM0?cc#b6IIY@d*_+61a2t2N5-NJ>4x4 z=+epCnwqvn$Cl6CdgHI5S!Ct!Z~xtGlk@oOzVp@$d}ey$qzO%Z(hY+TNGI=?KKkf| z4NL3ld<8jl5>BV3Sk!Y&LrJFF1kiDBL0P|{)92M38e6h#(u|=)dX^*up3Ra}TGGGA zh!9CjvcG{G+p0vV5I*2c%60-niyFawu8vGTgnCGEPF+CI_F}L>u!&%fFA>17>DC*T*MAS4%>qq6)ki8oxjq(>Z|brg)He|>CI0!ZTggzvSF;0O40d0 zM?zj=v3QYg`T98xsfn_9pO`vSjw|efyMJ5W46B^HJ|}&2j&FkZN`x3n0vs2cH+_nz zsw?mIn`_`EM+aFXx>t)O+z?2uur488!4hjlYJhL(x*LXlK)ejTx}7FWvGNUpiM1CH2S2e^6Rw>YXb@Dy$3~l>Cic=%?KlcLjw2H6i$~}%UOxB; z1twkbOz~aMq$q?b5UKkkIO8Z5DIJ?+>_<4Bz|Wt7UFGB$q3%y{)g$6@R9tgI;HpQ6 zHeLCQ%=>@wJUql&id_2t%k#jY=l`yKz~6TCAva`dNF}oB{@;32+JF8O{J-^nARJv1 zh3lb5O2FO0Ev5S4cA%t`B!L%dB!sIGqc6;t(_?ISP49?38CMu{N;+fr7z~-221C4! zeTUQ+QW`clU^n{>_KDVPu_fCo+EsK96%Q^R{;ewJbrPtS)#1a^o1yl>Wz>r_34s!8 zsa$pkv4;;!&CpMT!(r)%MF=(thgleYFwIz77A<0yuo!8Pnj+DbmdNhikrvJyVMpYm z(ww-T9NW;D4S^)C5U6+!?oXI7kS*n)X#f}l#mgrGc?&*C0V_be{CE)A{}oRu=bcqV zU`U}>AIW4srxqhtinOVu2x(AYjE?}%_98Z_@oiJq61D>KI>JXVP@v8i@I+FCa^@;$ z3E1E9*NQWc3js^Yi9n?&S_~sB!qF(B6HqBVwV_UhHYDj)(GQitlYnwOz>A`Lt*)#a z!Vf!Y$hy}OT1Y>n>&~iDmR)3VCW-)+lhQzt!~;4!5?sje#lQ0Cd<2h00ms80bI#1yvR2Su3I+3IE<=6l#hTwcAI%Rs)3>a+jB7ibyF=So*J=Ay1;6 zJLO9?=6TW!AW0gOI)1!qd`e}kNJ>c9op6e)E+iVBF-Si$ZyP#x89S4i@HDcSx2rmD z%~TikIN}hG4#B*cW&9EBYr;WDbWV>3*ky`8#Jy#l(-_n#1HE$uB5^44vI~q52^c!c zt`Zl3rWKJK`J$4U*B`(>_!vR7f&2qAfQf@v7pc%7kp`5^)WEYtEq)%rt+^}Nt<~Rg zhhFP8Cb@aT_U*{T>Ta9;#eiP(t_y6-%4Yqz*QZXOw|e!w=~D}5B_ynSYD#YIl&98B z=j%t+mWPMc@-|T_XaC)Q(v|Q;09p~b9h~?`af-m!Gogi*N^e%w_gG{`@+sfqQjK=X zvs1L1l0^ojZ&zmyXGlwok5KR_pWCE~}5(@z#^iYJ5J; zvroRYBj%c0yX!aepl?z!APl%{o$e0QCza4e3oJF9wZj@ozV>o^u_`{`!jSGRb_fUgGZSX}q-*QBR)Z|S_N(@iPXtJVJPfAro|KBBA*Ew-b8>RWlnyDXNb&GO z`?a=CxqMdGW{S`+EW)8#qZ-2vc{NE12}w114dKR7vqIO}Mt(A#C!r3V{D}&)_#C_! z+0siyTMl$k3K-K+my<>qQ!>VV$WBW-1Xf`jLN3`|#S9AJ1MQ>*P6V_>r}V}Y(pn64 zFxc`S58=ogF3hi$7pW|mfxIgai}myL^48)ElMXv;ibd^+n)2Envr^){({>o=s}~K4 zMn=q&-W;%VYK*AfKB+XnpAZ2+#Dv0Lh>9GZbb{6`1*y{e8Pz2A#$~0k$J4TYqRrkL zGHbM4ZGL2R$v}}sic^9`np>v*R8lSth%FehX!!`1SwEv?>P|LkgR?h{HEJJ~x(Rfm z2$`x>q!gCrWUS+$yQOBL#-Wx$vq0vMBSc6%?L4xpEf70~Tok;*l4TIa1c@gkR#R&n z9$)LN9bbDOJsfBtH{3AyXi88sK*ToM?tOgQ(qy}P>dx7>X$P2Y7#bbYbAFl>DcL_~ zQ1Q;GZhNvAsm+fr;w%&z8vWst>TF3vASXpqmE@+decpKXqZ~8(L+1h9t@$tYtrT`n zwW@c_mQ0yB(!9a5LIs?vZq%IpDeSSSJB3QBzs$qPc3yZkz(aBh<@p8fP6l2ksafCv zF1w3kKq~bCX0$8{YD6_p{HJV42$3;H?lKxt#^(k2gujaMex(6jZe;FJa7RL9poDWA z_EKX4iCC8L3gg8lPGNe_*` z<>1kzwAy_51rIB#W??ExpCs6FESBnG2eKL_rF|V;5$g&xYN$vD*MQo-nrbJ zfrhodBI*77sy_MW&-cmI4h>}Yvw~uF^gUS~Op~$k(33C>J9xrM=I>%w=q1n#L05u0 z3tdZAjS#*ph8iSAxs$?A+lMhp24T4iV#LZL+6|jWM=>a@t6Y%A^<1%Nh=imk(&y1n zhAetuCA%j(I&9h=ZOx(~>gEa2UuT5dYY=Q@vFb~b`EYwP%G!Q;Tx48knHbgstFw3Q zM2zJki;-2vB8daTs8*}WirW8r*BR*$%nL(K-m++jcjW_-ty2fj^bT2cv6)Rhw2n8H zrhB}p`HtjtFH#qpax2O*&F1Dr|HN9aCtY*cm>>VLtiY1Tr0i!{1N>E@Sr~)%RLp3~ zaCCW4p^mQAH8x?=!T6M^mWEI5R>WxxQ4Df##!y5|8bwc&O^3)>JeX@*%R#wB%V+@e zg@x7pe$O&pWkx|*;QNK8vne^H4P~q?C7XK^s3g<0f@T?CTaaF*o9fxbhYQmyb-UKx zqpRd5Mf;Delf>fk{j=kWQVLxm{q>qv<4v2#4Bz0GIoz>f_~?z+32QXVMB{Y(bz-Eh z&}53<%05potSgAI8Kw87zX^Z*%2Qw3D@WSw$?~#YNy`%0Ck9h~ZHZr+#ig1|1+|6g z(R;b$>4g^~C2URlqN>?@V`7plIT}ut8av@8{ph7Lhe{*Z_@OiBjnr?OkQ6Vay7E8) z7dF7HmBzbD_8Bgbkw~V>h+JslYfw9y1h7Zu@jE8~WhTJL%^>nGlQtr6os+@OiJu+h z)YtJP{oQR@wWa+P0(cJ50pnxg*P%=k{eze=`UmIkbLpq{FDPByH$HLVhJ^8!S+&t( zg&6Le-M7d7KYN*%{zc3Ql1hra9vo0A6GFraENYtaK~~SQ%u1RI!ec{&8v;#SMQCv3 z;M|Y6-p5%1_%QKr|)K%amH%&p9K zN)-bL9FqwmpeV5>nn;ZRBcNFZBa}O!8wq~o3DPBpP*C^8RBLyVe|)HO3Q@W>ljj#8 zLg4Zk>`-(EWcw^eI^q&BkVS3Jf}QS>&h3rSX><1f#kzmakc|me5UY4+@8!?>LZ<$G zL&ZZtpK2d*`JEoEag)9_ADfTp!fiF$3o~-6Ujb!m2%j<4W8Sd}|v5{B`c?qbDbhmmV55Z$B7sZdqRboc-ha=Po8kRhYqB|jl|9oH8(qVAbnQ{Aq*L9=#A7uSwM*=*vn~LWMeTEOm%%u2A9-2qYZxR?yv1mkgeiC{!uT zixi|FlO$M?Vd%KRPy(ewmyv{wCW5V}Z^ZR?*Y+zttJP`kw>z{i9Yjb0@r^7!QZ;hQ z$a;02^p5ny%gdL)%q%RIS>)1(*RVwJHH|)-^r!wGNZYL@i7fzINXH}vE~9G*xk9Ae z%Aj;GpusN6-}`SI_OqtB%7(;ExMP+n23SUx7(p;Q;*gOQo@Tx#DZ;go za+P+-htcL_I;i6?I_wd@s~ z`aihbDO?UGHUdiT=be)D)gM8(nTEEp!?vJgqU;Ssr*SG&gq#ICdu69(6rx6#t+ky)B)VmcMhyxY7I0aYLmaktq}@71&yVt;?;_ zEjS=uIJo)iAqB%?MtX;Qv-zNO;lKi2RW6&qkKOrs3%iMnS8gBT=Zp{-)-v;&cU#|GBg8CRFz&!R%a^`&`$Tv?V>4a@ZYu~S>q>5W_D<=- z9gC)xUGKWiKXvgPOnc|Ew_*FV#f#8qX21dO0Ona8-Ua-HRbF^kV}Xz?nGBF~4m^S= zueSz_o{WeLuNWDy6}f=P>nI zG;TSvFh7qg{q+2E?BK=;<2P;`KOuTwd|q0XFRtF%PriyVDX9+r$4N=Xq)~J|XMLP6 zD=jbHkz}%Y1XHTVg}mS%n<+`23nH@LmyfNaU$bFFe0*|`G`%ac*YI0P zZZ2}UbgoL*sU-uk)VW-zN_URvmD%@2>2EK-h=f3^yF;GBa}QUV5dFy!E5>PKGt+Fg zI5F0d*CRJzD!sX|;{rz)ufKN@ z7gF$P+eB1jz0$MEU?UP<-L0|8pk`!qT z>2(;M<#y13nbhY*L>9qZfha}hJnT)zwpT@e^v&d+DvDm(jJ#i`dB^L; zOGk<6+F~xDBDF{Rtt{62rFdv9N;h|{F087tzdilsh2qzC3N zrWcvu&&lNqJKMqy3STSJXg%yYOTg9c?nd!Q`b3B`s}hiL4NZZh32+V8$T|@68&1g} zKpdiRM7u)ts?4P12oXFleiUHvg~;n2GdEaaN__$?0Ay51_zqV!2Bw80FOTlb%oU6b z|Aa5jlb%wH%TClS-?DuYFCEpa+O%ULchf9BAx<#%=>PFX3-|^#v-Io#>O(BnZp0wr z79URTt&b7wO!GNkykLxTI0m+CGIK^8XYO15<|7$~82`dMlFRflLb++=y7wStJuAKc z-nw<~u}mbH&3y0EYfLcQMo&6Dj&C^ETRVTvhH>iX^O^3ChiG#zsZAwC^5iN)`-A!9MLkEPzm-VeM%aSr$82an<~s1zJJP+cs((|#Pdj(ZSJL0uzQ&m8 zQd#TCldUJ!DsJ_b?=y7w?PmAi^^i0#I{TKriBhHSB3t(niwW(QPDvj}hi^7<3pcXr z6>6MuvX#aa;wYg@dQG+{cvZj#^#Bc~iqsS#8bk01B?_l;XQ*KitRnjXqUtdZW+bsH zSP0Rt&|mQEg39jVOibXnN?%I7=T+GH+&(iVW{ENTyJf+Rnz)9Nky>+1oai1~X5Mad zmJG=%nON_yEZ0GNa%FjXK5#?-lSlT=jnC2c${Rf`-n{EZ29hFhBkz7+`sR{~<1{v-mY*~=lLOk}9{Qazm-E&~utQ9w|IPmH#2Uc!fId|)AV#0#m>n61B%--2LVcqTp^HwqK z-tSr6$tQ_7Wh>h+G)oVztsYUvrhM^7Hl=)c%?;8CJU7WF7QD9~;OP;7t)vf81&t3v zCxlY4E%elQNbdq~MH8GOI2<7M?Y-uwi+iYIWre$6o-pFBzil4AjA@o0>G=Sg_0wRax3IBEY`G^i zrFPlzC)uOJr}Qa!VByxbHKQgB@At`;vt0k1Uwjc&ROTN|1oMws#s!ddkCyE@u(f*5rnO#sF%E+)G$yoFE1b1 zjsxxd*>-G#r&5>>!vd%B&9W7fp38-K@y~cJH(8JE$OLKPslUjdj=Lj4j;t5VVL@Jm zNpdu1raF>TQmZJ@W>Zmmn?MJFr%TN0zPFJonI~F?QYe;~tz@KmMzyA<#+DS%Ud_)NI^?|{-y1S4$INu4#d?2F#!sESchC8^c2@)w%ofOm ze#5L=`}LhQw{LjCrl!ZX)bHH!>X{vZSWb&Pxz1##m7kxK)c!8ZT$4Y4^>yzJ8Jd@$ ztc!{97kbHn5()>qbw7S3$a=xb^%i8ise#+nr0f5n2?Lx+qXKV;Y}uQuLlNtjy4hI8AR zW}e%<=e#ARxJ1kI>RV<`@6&fkzeZ_lulg;IPI_hMjvav%4r#)*qT9^fZ+0(`60=9x z^T!VvI(rd2uXR|A9?iJyvLby!oY5kbhbyShBtj4Q8Tw2-`u#G}u=#@s95sR1N&;vYotx_{&bV^kC}t)_83$8%5Ar9oK;oUc*Ck4Q;VG`qt(uy zr9ExZhq+_do}4l5?#VTA(WXAN^&^r@J!Z|X>8VyH+AX1>y^5;FEuWC3GXo({SYGt# zsLZ!5bBl&&ne_I&J6swa4`3nz{2#oIIZL5hV_**?*A{2T#I*PaIvg>s9-}kWg~M+d zH)6+x`m6*Ux30z;;9UM;q4=IF<_#+17|5CL+I0 z9ZLmSL-9=QR&KRX=ph%r`bzReuV^1LWKwD)@?z^Samp4L%n=OEOaBu4vzu>ESM3$d zLZxZZRzd{MA?)13##Uy)!8K1 zf6%oXibNpH|Ei8Ykpa#{?i2pYAZrxIeL0ezkkLpKM~0&RvvwFw5%|wPuf&+Y@PZO` z-ue6a=XLGg|Ey_lLty?jE++^4)8(a>|8MQ(fE<+x)DU3BB3})GCZVaQf#k*iT?2`3 zNrmh)Qj5|uA2Fq=+M52eX5o5DD!?v#mG;KfLI#!sX zJ6R|OLn0Szb$2e)Jr`j(O!ue}jM=`KJ!FChyRvFiwqvR26#<%|0#czvj{htUb?M2W z8&}k8esbVaRL8^y1UXf0l^pk3xr^P;a-pzol-}V~G)#7%vnALbV9n;}V!AnZi&+RO z`=J@Xe*ku#+fB!H}YoVy1x+-*;ID#L>Sm;pSU#6x|VN-u7A-7)j zTYCM@gv{1v`L1ClDpi%4(EdC_{ZUmuOnX|JGZS{oM{+8r5`K@jzB2(PR+T4R-XBhA z`$+cl_wdaMKo}0EW15>~KAx~0+c2jp-ne*TvL_=yV1{3mnI+D^me_;ZpBXyKe<`lEN@#Z7jA2Uvb`nRBL3asYmGR(8U!rH{PdF; z4P>XTrcZ}t)QrZ&iMvUh1mfQgy#WKCFhAN zwsac9X;{%?b1I|VDtR?ptXPXi`1*>UZTD-{oXTc5YSlo}v8%zXw}u^BC>ZUS+Z|do z=FhkAmsEOtE0}bip&){1#}pv9qZjfJMX#8_my=U$hYq+ivr6Y08f{rR5{W|r>sY0M z{6pB>UV)>WC=GL%f^pil`azoZw*}LYy}UHV;NXQ=(QopZJtnib`@SF8orvwclatTG zsh9s*K9baZ@SyFXGCja+V$3elXYzXr3wvdZjo$Jw%XsiXdTyDHcYE%9n!Bz>Fcmtq zjbuB4UIxq)(82+=43;?!@O}_TJ1azb>Oguh9g=yK2wfPwAQ|eF#I9MhZ=_k$p|@_? zFgiXq|Mu&1%6nJ7$)>*b78^S z^rG}%U*0?=x3S+y+x&sC_vha^a?&z)t}9eiGIP4txVk*NiVbh$TfdbiOGBCF2&-l4 z0aKi}W!|LKt=}$vHtOQ9el>Ethus*XrFX38QB{x^dGfs{XK=>bedxfzdsYdRAAcO( z^6|&45)*@p9phHAEa~^r8>RDfF3I_d?iq}QDh#h~<$Ty_+#%R$kf0pM*Kl&vgveD{ zHu(c-hA4=c!Ra1SCwc7vHzb7|#NfY-OG6N_#K9ZaxfMZ;$VuP1hr11?KJ@THvv2s4 zxbpJ2CBuD9O-H>2&QOEjwDg945v{brWMG=cQ6_{-3P|ptzby$2Sy~9Yp+j=$vSf6NLEaeJ|-sT zwuy}sZ*#2~-B?-G$URmuDK5Vl2AexzLpfMb5I4DE*z)Sz^_@b!U!a?fUW5L?RJ|{8>gO=O6_VzmiYF5k zc{%u!ptK8F)dsMAP=VW^ywmuC`9cAtr{2sma@UKD?fny5uy9t}K{osT-~Ilz`tj0t z(%m~>_&djc@w>vF7Vdhjw`%aPI+ttf#a9k+U#|Vr8~aB6?v>{*J-_hiFt4XqiL^D; zp9|Krrr-R?Moj6sapJ(W1Is*so)iafxUI9V$}tEE5`DZ%g>HtPNV6|>Mz}o%Fw-g= zb%{=eC@jbl6vRPcDr!gp|G+jc*AzVhv4Eve?1lhIqot)5?&Hdwq<$E6*I`boljkH^ zaDhSu@fs>$S7Om(AsMPjjT*Trid7+hS5`u=0KH2Z#7qI1mDI*iWnKBUIMyJDi=~0m zr6)Vh;ZOdJ9b3t1lin>?OBt}bE^cKHERa6yC;jd4ZIZNqKN3;^$E$(GE|X?_zw(c# z?p{<~z3A>!f8@uMF9@DwH%A|f(SIfVaG6YAcu%mH=O**gKc0$?V7kxN@3^PqBK!Aj zyyg6l^4Z_Z7n0l23m&Eg^&}jZ4y=NZk7Za9s$m7%GZXhj4~*wWw?6T-aF=6G^jkJw zGPFOyrU7tw!)@)KEaS&U)Jozzy`_lxjF)UA=!FwK-Bfzg4T!ELu?B;@B-c;`B&R8gg?ra0$Xk=QZW zYRUHtW4#vc588BXvnc3ok&3zgv?_0!rHOcDx;R|@9r3~R0U23=^7@n!^Wd2@Z$wIc zc_1reKzcCVQQjACrEj?<&0Ce`pIZ?Dpa3ox2*eAS{s%qabX2~Pt{&d6q8!>~g0;Rkpx8Sq!AfX!ku z-VPkwNaF~-A^}-Y0tnD_AV`ocg_KH4^1NWEL#`oU4Ny%LEE#U-DmzZIWTeaLt29g3 zCQ?bs9D;g&T|i^eWW^c`$q9P*>bI}o@_BIH5La&4-7uS8hu|8#@Q&ARZu|2CKb+ZD z#j1Y&-)x+F*&VHu-C3~+Y_#?5YcrHq+a@#B7I&80?lIct&9fOjo+=xAvd1K6UO{XE zuP;yP+wc0fR`0$pVURnV>uT8d&c20%Za(vu2k!X7_4F6gum2SH+;xxK>N8raJ+l}$ z%TtwR^xRx0#lD(iv{iZTdFj`8d#bHALp=D6G~~AVNT!nuz+%d?B8}Ay88!$t&PU#> zDjwL}vioi_sfbE}_Ccn3+5s~G_7MJ8YBtLk~y^SYus6-talYa^tn`gn1d6OZVIIf)gjyCzzMrJToh6+?H2YuR61SY|Ucr z3@b6&3u;QzQVV)ym{JPjlQ=eGm?tkcy*Mw$s0oc-a^u87w{DzVUOH^f?2`QYoJ76e zmL41(wAdM|8sv{n4;J=Fj4Ka@Lw$nv02rqJtMF7xe7gz`x{7;lhh>5EL>SdwmIm}@ zC1{;Qgk~GEzSG!YSh6dBMXn0{W=*6d>aH;AD6>n_L?s)p5})3U&r^JHV2eVueOI)+ z%3H-O`Op$Ei;MD~K(r!_6!C9Fey;e<6#M;ZLGqR;ZPnwM((<+rKw`)QY&$>)?!_oQ-OE~}K5{y267b;UnoFO+qY7yceu z*q7=N}P3iDE#22h$|7BcJgLYe51o*Al%ZL#Qe{2&RX&tS+x=`~v6NY*z@W%)?fcc><= zMcLm~qU-2LRRy#9g_hV$DucCM8*I@kEo63di*tRL-@&UCH~1{wo`YA)uP zedtaU&uPUtP{DJ=>P9vM-pZ37A;b8WqcH*aAtP||^?Ud2+q;pSm(HnSxfh-q_Y+_o4?H1+To0Hg)WIla3p} z%ZCq;k~_f-n;o{+h$r3Su!&eb*RdH5AgcIFebrI%8H{v2l&x;$14FJD$Sfgy7MzWU zJOzsxuo>`>RgOdNTUMD^l?*+G4SAx&}s$JNa1ork7vI&+NCoA`g=ms{=^s!ODcYr&Wxiws%`fYXZkgv=!QmG;uZ-IdX*WJ!|{ci%qQY!rt{#ri^_MnL0*_KE3)} zg?)g%;@s+|rRbQcKd?jWD|YAyuDK=p&iFKrO=@TwGMTX(TAH6bHe=nPPi8kV);Rl< zL+fT7dybOMW9FfL0=&#F-HIY-*4*tO3ai_d711Mktds zA46zF-%qAliQKm7qlUR1o;+~5B%3O2fe0&d8D0anlcelK?o5C{aeQP}+4l1(X=C&m z8CBC81GzdOcgV7(dm8RQYLP&~z&E8~0~QbOQIX$}fnju-1-`jySdwTm8dc?YCa{+S%Hziw&#XJw}12sE8f;` z(aHP2JpRX(BSyH9urZN~MG6m8q(d)?dJx(M;Zn>*?edvM@WPBM+nG%q=qtGV5^}K& zl|U_uA}r2u#e`c9c>InLDO@FsfOF{X&z63*tRhY`(bxopFVFAvy7;O)(LLv_J|}%~)eWV>Ye-VW!_hGt5WRo#)FrX6(+t*}vutVB-dVHu&Tjv3&e-j{U)bBWd)fA$ zXStvH6huGBE@OPJT=tN5@w)f#ym9)LUFXK%v?QM8j{a4WSlgKRu3KZ1zH}D!D*oER z9+*X!X??MB`?B4wd!OICy>b4ov#1rxjGg>GdGC(Jxacx=D~vP)XaKz26hpXd{sx?Y zjC(=;B_t7&gRks>!g-M>D~a<~A#9W8w=T(mU(}Jt_y{2{B~|96dlTLACTDy}a$+EN zbZJ>eVu{WYqn)Q0G^_u({tw?v?cY5(W5$EuF+pClT~{;3LvS(Wvh4HXAr(nZ8-Omo zw5=|+M_Q`I7?+lu-6P&nZBP%>c=XNx#d_g#-7hOWb(N@r_Q<%zi(~NKb@1aDtZG6V z(L5zWnvLLx8cF=u3oAbds)J@N{Ihev991`^An z=g^OI<|4PD0DCwxetcvc+tIU^N!kT}5ndCsn*FL*oW)QaNQ~pTUyCDCp`mbSH1=d` zjFA63_t*w6yI%u^jYgWEGcGnZO&wE^T9pZlEw_f>lg#U49O@;~8$5hlVuaVm)r7~5 z3)e(bi&Nnd`=mj`@mk|{>97=P&i1H1amJqUR&ESCa?dBRX+Qwxc!ML>%&{DHLrP}! zA4nC&jQ1{XDGN>T_K9~HympI@O_Cle(u$lIlchg_^l5-V)R8h@gHiKGok~amrHuji zTm)>i>Bygn8IDKLff66Y{$Foj0v=V7wOv)Wx1>9rrL&Wb?17NAyOThGB!mdEMOkE% z(CNNOnsmC`Uf4v9ii(Pgh>ngRsJM(eE{rpSj?VC@qqvMZjtlOn%nXj}I4-Er{O`H< zb_k5~{onWe&+`XP*LKdSbE{6Bs#~`foBCN1Lw_0z;<_gKpop~tDN2am))0iwNyZX7 zTGNizGmQmO;r}2eiyyg{ON-@|PWv+7u_w6AdcbOnz1x(S7W*c{mL#eZ()es^x-{v> zXJTJj)6=covY+3`lk+BzZ!B-g#mOn$n%i7HzG_N-s(1wPQ%=O^#N)A3L&0xW@#FDa z6!3&Q&sr7R5aQ1rvk>Dpwtq=(?*B4gX}6ex(|?8CSIhB+auK=(OzzM^x^i^DG;xDd0&#;FPX53<1{r@^ zp^7dzr}Pds*eseP0wKmdnAkI9Vl<8@OaLh{xO72@zza9{C{cI~ zHwteqMiwRAf86ULaVX0txSmaiMesZY2rQg1d}O=BkL64tITXHK@5(o$;|Hchh_2j7Z)_156} zie;sorS7+INO?S|Rcx#9vZip?uVLwGI`v+(LSVmDp=<;5O z9mcC5X7uRCG>rEeb*x*6`8Mh$rlK#VyS94J9|v$I;05e5b`5U(qXCt=4+N_dn5dp`L1do8qiceuWy~s&nk5kc#nrk#YjF2r5oY zbxscH)yQM2qlJDFQ={W6Ro=?4SfMyE)lq-7xRU}$t;$)^iWot@<=+E8s&SI)XrZ4% zR9UFwUuHOpet_zjPK%$7?~7jC2fP_W0j)Ninv2`cId)DdHKg{Im?A_QM2#uSIJKt7 zXeSU&ai}*g#OngPuPBb1t(J^Q4`r1g4gWFkNGIfC`6jI!r1hck2=%@HZ_3;Me9o5Q zjrEsGKzy8KFD)s|FHimeO{zS1)eTvVrNxyMrRsGHz=_}Ma7@AHU2w1yXd|2#dFhM% z3S~TJ8*A*`j$?3B?HRx2WeFKMW=nO-@;_x7Q&Q|1pWLZTI{aLndYEvWE#>SoHNYmh z7uQymluzlX!ujKvm08u|T3A<6V|O*FH>{9M+NBY1DW9`~^s@(*@w_s-O~=B+o?(<*X2*&Z6f0~UhWE6j z7IQU<{i6>uuzFOYv@sQ?a6DcIutp38tlXe!!*&@bZs`H3GR>_l+5{1hF`I?&$GGZO ztqvsPZgLQ!t`xsIX--uJqe`Y&O=wi6;4$@s-CcSz$~x1eoYX00j#;IN#dT#OEt!y?qvGgHrA?!;(*B#QxHXTLP+p=< z;JoZvj^?qZ!ir+YMVc#=Se{mrn_8I4J@ZRvr6we#&MKYn5n{|*V+n7|s!v+O%{TK@ zPmXcQ+}ugi7oqK3|MRw>h( zJFBn=tfZ=Tv3n9)&#}$K7F>%h1_OSRKF&GqChxMBF#B|3J~$m`zzk4nK*8xhDI>7w)#j_mx}6##*fB>P>S*=7;Sc z8&a=*tY_;j22niU-dmepTa<&wY0S*;JhOPQZ`IcB%q5u?Lu(pO5XnbR+QNrXD%Qj4 z-@;k-IT)wnTNy19F&a<~v;`~^+CWBt=4COgq7(=LtibkFiKSl4Wle5+cAWx_Mz(4w7`niw$aa7{!*?LL7eNkqiZN2WL z?EJ#ytckJjF0YkI~GiNVVEy@>@6S;^^-mRNJfWIXzozVvf0 z@oaNZ;pt?z}Qljyn4@&lW zp8C+kv5%+CSP}E*r7v2aSDClxd>oCGV0>7#Jh;4|A|X8`-I8g_l70+5on%XFOZlrU z_SxaW*@aiX-}ZD;dIBQWNOog(mOkc;&5-cUYm{c@RgOP4O_x}0_#@xpa7fjb*dvL3 z%L3SPl@VldZx<)xp$Csk*pVLtUOKhwqZUd$QRVy!2A$52a2GXhx# zBg%lfnId{~!mS7u>6m=O?owO^VVB;zH!}mTMMVO<$ZhiJ)eDc&yqPwrMBYNl6R&?b>3HmsS!*vSv#q!`$2qBNL2h+H%EF1>Z9|jiVCTfBdHh^fh1uRt zT2+S|4WSb8!717{uBE^;W4pFfLNs0`GbeGJE=c-@>l=Wqd`!nfl9H)Iu~X)Nb-8&} z)tNs(eDn6OV}dTLwf*NWy~OP=?GcHE4QI7vWF)>_uIrw-oL|^jHGg_{_UV`8>#pjw zPi&lv6_PVYcMklExzlqJ8rq__-yRMB!ZyA-*|zeqN=7>XFM~S2URn5i?k1z zruHaWz2^%(1jSMBfu=^z6zWLeV0vuybeQgV=CrO|_I=JTK3l_cpFI$Vy+3S(Z~Y#W`iE)4pV~b4p=u zS@!(YoOF}%ZJ^A(q|`EX_EdX*az}caHDOHK0sSz)^4y8*YPT52l;#yx+bZ&s^UmBf z)?zl~ca1eSmnG@-B~_JU##C07==I5E6U}40@(pH7(G_O^u_AqZ;h3^qM}0oO-%}o~e3J13fTTS`u1!pHU1}K4baXYQ3)|6nXeQqg~pnOjGY>|?qDuLNbN>EEm zkfRI*b@CQm>isj)`IA*&sxujR#pCki~C9!y`25SoJ z4m+wjjiCwXvzn&pFsM#o(}Nw3%uFeeN|W1j+jbX9)ziC1!ui8oAYAq%EC0!_;y-$<=X#rd#{SKc zw0ZwqKYTTLVPN(d^<%}8x!dgyr(L{z?6>@@AAix5rn4^GoIkDjS1<$WS@6pDLL=t< z#^U7N7Fa_+Tg$evzaw3n@xf~n)_vgf2$@HE5BQ0|=mg9{(4t$ih)w7&(z0L|RZtup zMVeMYFJv&HDh3%%r+RiB4Z852g5F2zYLpbkBBMR(Y45!bE8FRnmOdLR4wWi-&}CN; zI$rwd)lTWe(JkR!MH#J=4Ahki4EM;=D*|Oo3yPbIi<>X1YOSowFQ~e&vbCzJAiwJV zD!8q2hg%lJ4m@z~Yg^9D7`SL{!Q|$Gq9%a9sGvEoJ}G$7)iY8HdYm5?%-^#$;7*El zwe_}5^-LAfSwHKYv!$tSS)XG`DHgx#W-a7d(^@CSK3}GrG+txS1SYl3OMR=)cG}OG zUR1GU*1o#zvFb)bb7)|d&CqPmP49d%6o`G&(Y7O(hsL+5^wa7( zySc4!rLksTsCl5}^6lp@u;arHHX+oMrw2Cb+FJBReQL6e8?tf0#uZ-{)OU}5htI*< z5n3f+ufWv_^k%NiDrRXTFsNJ^)(_xH0o*i@(KvdLAzg2X-SDR6yl(gA&F-^X2YlD> zI(Tr`9nbS6LqmT2@w8Kh5Ms^P!i}?+T=VoblVlIAuXtq*;raRMQ%467N7+k8-_k1( zz*Z;d7>t||CnM6QPUUl%L0SEbaRStilq}Q0>hIq@GxpKK-7oH%I(zsx!?UOU{wBBE z`lNl%V)GU0x#if)`beGCKB+EtzkYE}uyfh)@UqTePG@zps7e!b84UU)rsJ3E?DNxm zl3TxFW@VJl{<3sg4K-PEj~~Yk4p{PzKNI?LqEP4zm?ff#U8EmR;99(rNI&9cX_(%c z;9CgveJT+5p8`y=Fl?BisTRe>kb&`GB^#CTKKQYm5~sK;E~Sm;!@pL-XOonMQEB8S z&{Le|A4P`~Hkm(;L$s7eF5x2{dk@txXd4tfEgX-JyF{lOR_NOZkDfyZm;6fJY=jTR zC1S~ek`|YVaPVq0lK&_fPkPRgc;HjsL=$%v*(n~N$b&R3ZoTq68t&+HY>DHL<>!E< z@n`uTxNQo~Fmr&HL&-zsokaO4c@4AmaXyqzapY={qT$5D$}=EssRFF_Ifnj4o@sSAd*VOEXu?1|%0-6(P*P00&#AWdlg zkvtWAq8|;zEQ9bsuaD=i)pd&Ih7r#-9NlPIiUTB*tHcj0vW-EQ@*l|uONtboCLJIU z!>kQJ&!L3l@gsbI1Airj;~)*IGALz@c%o6#hE?A2GScwdMwiJ*8uE?PfX|4G;57k| zq#I^)2p}5{2|f`fUIa*^I#!uK%5WKNRBq(CLwNuMk^qv zAbNT>&0R_51n335o&fk z`AY<&dHj^0L0f<)s@x=-ZtIw(7je$(`j0!z)+u%2A zX(KXI7woFPvO;?gKD4R3@$!c&l* zJ(_931;DiuXmuKwYebH?OmUawAU{F8EXWTTm3^n9 z<)rv{I8HN~Ua8yR5q{W;eS#;+4xWPI;1Zv>y%p3(!Ox(j3HX(EL3l)`J$IZ=3CHs% zm+0aU$2A>c3+Q<${8Qybys7?)KK|UqBaR!Vi}O9zrF4S09ONe)dZ|;s(LDlF|@Qc0+weHB5e0--i`_l;Uk%%Vz{1-;K(k8)~1Z@lf)^nOx** zvM9D8o(JN~$p7E`RU_^H7qlX;UFZQy0e3@nHv$f#Nbm)fN?x}XB{Ku1gn(%ao@hG& zBiBU4n`Z-#pgRFw(k4{x3m5_*oPuyF_@(ZHsQ`@)FEh5Icv;@fSVj@xVW`4l#tcK(3mV0Jyco0HoE~0pL~tFk=ni-MEo4`vL&M zjyAw9zyWlJ@H;mEK+`k;*pDs^ay5fb^Q$n4kh=x$M94hJ0yxN6>lVf)1EwrzY%1iM zinOW7yAAYh;M3j>0Pl{qj7`f1An$39LG8e6I`F3>tqbAPfOpza#%6-=%=;KSeKBLR zUSJrW06;T$HUM(Y{hG0PFEiE+nYtn084CdW&}^y!n;DxAy!m?>TY&V1;JG*j0KQ8r z8C$j-a5rPi!TaoVz{8BK=)|y+0U*Ol(D%+@%nce(DPyt)5CnXQrhkaBe(>x^o?ai| zAY-dMXkOKTuNm|0Lie|lG5>7F0!R-cpL2j4W`OOCMeKkV7>f=tcJ4;THh}*I@Hh|g z=K=5h`xv_bat|Z!!dAe8j9m;q8=C<~7`p_tmzn@u7`qJlZi2j*A7boE&~N^fv8#Z8 zHPWsD&6Z98(ym?0*w#7#;=A7<>{ zYR2vZuV1DB5We36Kwb~D0$ye8K_6oe=>XdSUoy6*6L2HoQ^tO^fw70P0oxe+btwRR ze*<2>Il|a)4=}bj9RRvVfd6P70Q7PA-3yF8b~j^>dl>tDC1Za8zkP=pd!i2TAY)HL zzNe7aQwJIQqaE-LV^8m8Z2w}$o;3kB1HNYLx&4ei5B|>|VeC&9zfcuwH0ODWO0lFD`4e75v%-HK|8G8eCZ){}jz)HXijJ=7tH<9;S zKETV2yvLPQ8VBuV~1{J?61K8 z+X2S@4!pxU0OCLXlCggPJ^_6CDPx}PZ`T5le#8#g z&e->m_lFsb{Ro_+;CXZ#06dPh0=57SF&0By4DRtS@y5CtqxBciQ@o53!QG4}v;qz@ zo)`om-TV&YmJN(2=>P{9PxfF+#RNcH8t`rDfPI*b_A#CToDB3jnRWnhv$ivyy^`^q z1&rq|W_(N?<9QDUbS;%9t1pu5S?=Ze}CF9Fl0l;65=REsC##bP1CGvGaPS+O3 zd-0s^YQ{aojLXQo5BUAS8`#9S7yMSuW_$=~0mO&EGYbBzL9=Ev<7+oEz7BZnJ&d0V zcSAN{7vtx51CW0Hr;J~)lJVgI#xDf!MU{XX8Nc{3#y9R}{1W&tL)s?rzr339D+snR ze$@;B(ys=eYb=a!Nnw2JX2!3B3svIVjxc^b%JPQojNiDH@tdAv{AS>7*8yH-9CnD` zk`6e;_|AQd-)ds~wmQadk1)RbKF06Z!1$fW!0v78X$Uv6ale&i4P#9^QK0|@{6Va9*sVI1~`@AUzWGX4m7!rt&lw=@1b;Qubj z_+y=nKTd$S-y`2Yv@yO9&$I6_#{cUm<4?T9_>(s>{?u&7|5yY##P~Bh#`goB9cKJF zq&@#N<9`Az>cWvbvebZe=287ZbVg=e@v0z7KHde+8T| zafisEnO^(}fI55HMnUB-mA!)3RIZ~TuX-8@`8mr(NR7u~WjGa6^-DPO`6A7)W94kO z=GU`Q_MGN7fcA6EZ)CS|o#r>OY<{QaPhjc%_nP0##__leR@TaoYVrG7rfAmu&$2o( zSMxu|OyYda|2#_+m#Y3ZC6+6;;2g;S3$k@MQ{0QSr2~+>2rD66Y&F)26|vLc^WzKQ zI`|uK)=WLVW!1pn&V2Y+G>R&$gk%hOWW*A+2bf*p?g!6ytP!WQ0M_fsShpi1uP8XU zfZK(YCUdd&Vm7ckaGJwB_`BG2e4Ffs|4b$HQ(THp;j;)_L&(Fcr;3YLGl1%A}AM1`KhuZ8aFWFx%Pn~G>V48R06~$ggiXJA5xxs z5OFTVQoI+ph(+OxbMb?ULT+G(wQ>w0hDv^PN&Zw#Q5{B5rxUS?rxs75=I=U*u13k} ze~wv;5>ln{E2UJ6wf{0?j&m=9X4F7G7NDe}kdjX1Af2g))~LS|k=g>8>TxF930)cl z7a6irnW@j-HBw&l**W0lMGDmj+OpOH|AQm$KmyJ&XIMMQu4Y%VE7(=|dU-9DzTt3i ztU5Dt6V4J(nX*)==`pQh8eji>Vro{3NM**Ie?myf|Ny?kukE96Cd zEHB2s$WmU$%XtM(p0DELu!y>v(^9}%UWcu;4ZM-tagUx8+lrg95qTok2e$Ib*fozE z?sz*+2Ajq^acp@PKaJ1eGx_O!7OvZw!{_pOyqllF&*bxQtocH|h@Zt5<1DkKd>LQP z&*m#|MD|MV;=SC>JzVB}yq^znFJHw6ac#{IzVHWlke>sK^94)7+T1XYV5{U-dnvz+Z{n9@NyU|XGrx*o&9C8Ga7*h}ejVS& zuje=LpJB7mP5kHlW}Iuc11Cr9ThZ;h*x)_~-l!{w4n>|BC;Mf6c$)-}3MH5&k{@f&a*l@?$*4j|(Qa5JD0< zp%+-sE=(dpBnmUmvrEF>^kk7DQbn4uiFA=6GDQ|E7TF?4QsQDXPRcFj5UA!R0ibsa2XRVS}I4Cbdf)(ln`4nl5!o zr%5xUnbPUfENQkhN17|mle(odq%)=Y(gF$B`buX>i=`#fQfZmATsm7?A@xWrC70AI zxh0PzOMOzmG$47URnnm3lZGU}6p(__IZ{XpOA#q5t(MkEYo&G4dg)wggLIyBzI1^! zEL|vFBwZ|RlrE7jl`fMuNta7kNLNamrK_Z?rE8=u(zVi7={mN}81;MW>e}nbZK$h@ zyY*VQL30~5*RHt^&2?&Sljb&SZj0u&t8PP=>N-@{(KSuq?{kI2`k`pp>o$aCSI9kJ zlKrb?Umz&!2M~_v!Vy;}k$!sQph7NIN(YVSHBJr z*7XJggC_bJa)k!%9Y3-}{Q_jwH7h|A}7nvZ%iX0P7^Je5xKE4bD^ms_S% z>sjsf$N^)}>yAW2vLPt@-CkefkSo|jvdSTY%R>xN!jMz;cq97ofGZ^H-2*a8h$<{8 z9Fc=Py)O6Q8du1Z)aODG#zUsKM@NOO54xZPP>ev(*cS*9x<-DY zKRghKBxz)-RwRH>^(FSY{Bf@<6bh_SO46))6)8-rKN?I_J&HysMMQc8al+p9a!+5> z=d)=3@Q};rOOe;QeXb$bh*-LQZ(l^`lU;piBO%!&uY;nYHWJ9=_65SS1?A=U`ui2x z^(arjY;wDNvftwh8A2|*=j94SYV59%ISBg>H_JbExl zEZu0ZmOf~q98xngYXK4=SrdG<9Ey06W2zP&2!y=rp}sC(0yMtI4ZVn1B5S-6=%rfl zq-3P_O30#Wd=D}Y1*AcFoer%zY|=yyCq)LLL%rdiXpjmnSqqW46i!eK$$-n(XI89> zYEz6lH?G~1}uz!P%$B1zX6#C2iBSUy~v?g)dST! zP&RrWY>;2Cw0ERKOl76b?%R z9*?OP+JM6I>w0CM&+MjR?L)yv#okQDzCfA+Ox$c7^3c(pgJ*#!$BxuX$OWpG_$&=pkl#~ajzU906ps-2!*DC!_IE)arpiKtHme6ScH z@1PtR0K@))geYuO2yA7@(Cd@+P+qSaWR`VAI5*g2AD@h z=uwCAx~`gc+k^zWoF)k@+Cdb8?P2u-S=EULnvP>mirJcw?? z;By7ZQ4}R&84C2$b1ALSqUpP$Z;9tb0})j;v+7mr8Bgo?<6%@>J$irNxWU1IB*z?m?Hw1T&}Tg^9)z zL}pbyifMsfdrT-}^jT98LhPy_;+FL}h?X$Ap{xzQ4gu3t}O=atN?~EnQDzT_c7J82XV= z2J~c*7f%}>IS^0Hl@tG!u*V%CWjIM+8Ms$D*XsS`%Crk+hz zkQ15$)g|mENsfl3{@$Pz4SOW7KP0URu9HI1UTHA2M(T~YX_zc0jI`Ml#SZnZgNVTa zS1(#*Ph&$%+DL2!=Cn5&k;9q)9z~Cp6pvPHaOz1RN(Z|}JN-B;>(HA1kTYJ5cUKn;* zW3?J!34I}RL~)d;WM2Roofu3djS5GDqf<$*Qbwh!O?(Z8xq&rdBbsR_;PvRyFrsTA zrni^+mhj-ZAUd@`G!#B3icSH;0jNsA&{Ex}l;pH}0vHb{uOC|BH#J*U zV~$cr*AY>D z9sN*hJrUItQ9ZJ;*CQKyJyFyXMLki}YqCvKUQxU1rx9HP(KQfV1JN}QT?5fI5M2Y& zHBe5Clv5*7;DiGF5JjUVUZ=*eQ+em@s_#@Vh_q455@!M9?HDP_+b&#UZYLgg%GFM} z+9_ANl0c+(jdVI??4XPt#MVJX4kB_8k%NdFMC2eM2Z`z=3MWxuZ$5sA!l{YcrKAy& zvk6twr=$^46D2eeQ48yRNT6sYWOTd`bdQkWx6H6!-y!gOtKSO5vzO9*#QX z;UJB0kVZI2BOG-t`qeUQDZHc-4&vn?m2i+sI7lTNq!JEN2?wc!qnpikTN*Pd^xaP13yI3NED4k(MS|_qOcQ% zohYd49aQxWs(S1TpdX^J6NQ~997I9&?x1>iP`x{--W^o$4ytzt)w_f0-9h#4pn7*u zy*sGh9aQhw!$Utr;Uo%FI(~@4*@Dsr1%8MEl@1?KP^CMl(jBOD{163Ix`Qg+L6z>H zN_SADJE+nfROt??bO%+sgDTxYmF}QQcTlA}sL~x&=?KF4V06Us@_Re@6_x;L$lhP8Yn*}DS(p{z)2>-NxI~u`gcfcHA@1**7QvEv{)MnYB&UbY+w5x5t zp;Xnce?6!XeHC3 z<=dg<+o9##q2=45<=dg<+o9##q2=45<=dg<+o9##q2=45<=ZhGYYFW4;BcA$1K@1# ALjV8( literal 0 HcmV?d00001 diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff b/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff new file mode 100644 index 0000000000000000000000000000000000000000..6e7483cf61b490c08ed644d6ef802c69472eb247 GIT binary patch literal 90412 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%0Ded40&XED0GYFoIh+AV*?9!MR5pBW?X_8Bp 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 IH>08b4`|GD*#H0l literal 0 HcmV?d00001 diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff2 b/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..7eb74fd127ee5eddf3b95fee6a20dc1684b0963b GIT binary patch literal 71896 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≠dR0E9ICQ{-tcR;@{R^I5P#1GUH!p=-{c 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 literal 0 HcmV?d00001 diff --git a/docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js b/docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js new file mode 100644 index 000000000..ff7be7141 --- /dev/null +++ b/docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js @@ -0,0 +1,240 @@ +require(['gitbook', 'jquery'], function(gitbook, $) { + // Configuration + var MAX_SIZE = 4, + MIN_SIZE = 0, + BUTTON_ID; + + // Current fontsettings state + var fontState; + + // Default themes + var THEMES = [ + { + config: 'white', + text: 'White', + id: 0 + }, + { + config: 'sepia', + text: 'Sepia', + id: 1 + }, + { + config: 'night', + text: 'Night', + id: 2 + } + ]; + + // Default font families + var FAMILIES = [ + { + config: 'serif', + text: 'Serif', + id: 0 + }, + { + config: 'sans', + text: 'Sans', + id: 1 + } + ]; + + // Return configured themes + function getThemes() { + return THEMES; + } + + // Modify configured themes + function setThemes(themes) { + THEMES = themes; + updateButtons(); + } + + // Return configured font families + function getFamilies() { + return FAMILIES; + } + + // Modify configured font families + function setFamilies(families) { + FAMILIES = families; + updateButtons(); + } + + // Save current font settings + function saveFontSettings() { + gitbook.storage.set('fontState', fontState); + update(); + } + + // Increase font size + function enlargeFontSize(e) { + e.preventDefault(); + if (fontState.size >= MAX_SIZE) return; + + fontState.size++; + saveFontSettings(); + } + + // Decrease font size + function reduceFontSize(e) { + e.preventDefault(); + if (fontState.size <= MIN_SIZE) return; + + fontState.size--; + saveFontSettings(); + } + + // Change font family + function changeFontFamily(configName, e) { + if (e && e instanceof Event) { + e.preventDefault(); + } + + var familyId = getFontFamilyId(configName); + fontState.family = familyId; + saveFontSettings(); + } + + // Change type of color theme + function changeColorTheme(configName, e) { + if (e && e instanceof Event) { + e.preventDefault(); + } + + var $book = gitbook.state.$book; + + // Remove currently applied color theme + if (fontState.theme !== 0) + $book.removeClass('color-theme-'+fontState.theme); + + // Set new color theme + var themeId = getThemeId(configName); + fontState.theme = themeId; + if (fontState.theme !== 0) + $book.addClass('color-theme-'+fontState.theme); + + saveFontSettings(); + } + + // Return the correct id for a font-family config key + // Default to first font-family + function getFontFamilyId(configName) { + // Search for plugin configured font family + var configFamily = $.grep(FAMILIES, function(family) { + return family.config == configName; + })[0]; + // Fallback to default font family + return (!!configFamily)? configFamily.id : 0; + } + + // Return the correct id for a theme config key + // Default to first theme + function getThemeId(configName) { + // Search for plugin configured theme + var configTheme = $.grep(THEMES, function(theme) { + return theme.config == configName; + })[0]; + // Fallback to default theme + return (!!configTheme)? configTheme.id : 0; + } + + function update() { + var $book = gitbook.state.$book; + + $('.font-settings .font-family-list li').removeClass('active'); + $('.font-settings .font-family-list li:nth-child('+(fontState.family+1)+')').addClass('active'); + + $book[0].className = $book[0].className.replace(/\bfont-\S+/g, ''); + $book.addClass('font-size-'+fontState.size); + $book.addClass('font-family-'+fontState.family); + + if(fontState.theme !== 0) { + $book[0].className = $book[0].className.replace(/\bcolor-theme-\S+/g, ''); + $book.addClass('color-theme-'+fontState.theme); + } + } + + function init(config) { + // Search for plugin configured font family + var configFamily = getFontFamilyId(config.family), + configTheme = getThemeId(config.theme); + + // Instantiate font state object + fontState = gitbook.storage.get('fontState', { + size: config.size || 2, + family: configFamily, + theme: configTheme + }); + + update(); + } + + function updateButtons() { + // Remove existing fontsettings buttons + if (!!BUTTON_ID) { + gitbook.toolbar.removeButton(BUTTON_ID); + } + + // Create buttons in toolbar + BUTTON_ID = gitbook.toolbar.createButton({ + icon: 'fa fa-font', + label: 'Font Settings', + className: 'font-settings', + dropdown: [ + [ + { + text: 'A', + className: 'font-reduce', + onClick: reduceFontSize + }, + { + text: 'A', + className: 'font-enlarge', + onClick: enlargeFontSize + } + ], + $.map(FAMILIES, function(family) { + family.onClick = function(e) { + return changeFontFamily(family.config, e); + }; + + return family; + }), + $.map(THEMES, function(theme) { + theme.onClick = function(e) { + return changeColorTheme(theme.config, e); + }; + + return theme; + }) + ] + }); + } + + // Init configuration at start + gitbook.events.bind('start', function(e, config) { + var opts = config.fontsettings; + + // Generate buttons at start + updateButtons(); + + // Init current settings + init(opts); + }); + + // Expose API + gitbook.fontsettings = { + enlargeFontSize: enlargeFontSize, + reduceFontSize: reduceFontSize, + setTheme: changeColorTheme, + setFamily: changeFontFamily, + getThemes: getThemes, + setThemes: setThemes, + getFamilies: getFamilies, + setFamilies: setFamilies + }; +}); + + diff --git a/docs/book/gitbook/gitbook-plugin-fontsettings/website.css b/docs/book/gitbook/gitbook-plugin-fontsettings/website.css new file mode 100644 index 000000000..26591fe81 --- /dev/null +++ b/docs/book/gitbook/gitbook-plugin-fontsettings/website.css @@ -0,0 +1,291 @@ +/* + * Theme 1 + */ +.color-theme-1 .dropdown-menu { + background-color: #111111; + border-color: #7e888b; +} +.color-theme-1 .dropdown-menu .dropdown-caret .caret-inner { + border-bottom: 9px solid #111111; +} +.color-theme-1 .dropdown-menu .buttons { + border-color: #7e888b; +} +.color-theme-1 .dropdown-menu .button { + color: #afa790; +} +.color-theme-1 .dropdown-menu .button:hover { + color: #73553c; +} +/* + * Theme 2 + */ +.color-theme-2 .dropdown-menu { + background-color: #2d3143; + border-color: #272a3a; +} +.color-theme-2 .dropdown-menu .dropdown-caret .caret-inner { + border-bottom: 9px solid #2d3143; +} +.color-theme-2 .dropdown-menu .buttons { + border-color: #272a3a; +} +.color-theme-2 .dropdown-menu .button { + color: #62677f; +} +.color-theme-2 .dropdown-menu .button:hover { + color: #f4f4f5; +} +.book .book-header .font-settings .font-enlarge { + line-height: 30px; + font-size: 1.4em; +} +.book .book-header .font-settings .font-reduce { + line-height: 30px; + font-size: 1em; +} +.book.color-theme-1 .book-body { + color: #704214; + background: #f3eacb; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section { + background: #f3eacb; +} +.book.color-theme-2 .book-body { + color: #bdcadb; + background: #1c1f2b; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section { + background: #1c1f2b; +} +.book.font-size-0 .book-body .page-inner section { + font-size: 1.2rem; +} +.book.font-size-1 .book-body .page-inner section { + font-size: 1.4rem; +} +.book.font-size-2 .book-body .page-inner section { + font-size: 1.6rem; +} +.book.font-size-3 .book-body .page-inner section { + font-size: 2.2rem; +} +.book.font-size-4 .book-body .page-inner section { + font-size: 4rem; +} +.book.font-family-0 { + font-family: Georgia, serif; +} +.book.font-family-1 { + font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal { + color: #704214; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal a { + color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h1, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h2, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h3, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h4, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h5, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h6 { + color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h1, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h2 { + border-color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h6 { + color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal hr { + background-color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal blockquote { + border-color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code { + background: #fdf6e3; + color: #657b83; + border-color: #f8df9c; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal .highlight { + background-color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table th, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table td { + border-color: #f5d06c; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table tr { + color: inherit; + background-color: #fdf6e3; + border-color: #444444; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table tr:nth-child(2n) { + background-color: #fbeecb; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal { + color: #bdcadb; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal a { + color: #3eb1d0; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h1, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h2, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h3, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h4, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h5, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h6 { + color: #fffffa; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h1, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h2 { + border-color: #373b4e; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h6 { + color: #373b4e; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal hr { + background-color: #373b4e; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal blockquote { + border-color: #373b4e; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code { + color: #9dbed8; + background: #2d3143; + border-color: #2d3143; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal .highlight { + background-color: #282a39; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table th, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table td { + border-color: #3b3f54; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table tr { + color: #b6c2d2; + background-color: #2d3143; + border-color: #3b3f54; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table tr:nth-child(2n) { + background-color: #35394b; +} +.book.color-theme-1 .book-header { + color: #afa790; + background: transparent; +} +.book.color-theme-1 .book-header .btn { + color: #afa790; +} +.book.color-theme-1 .book-header .btn:hover { + color: #73553c; + background: none; +} +.book.color-theme-1 .book-header h1 { + color: #704214; +} +.book.color-theme-2 .book-header { + color: #7e888b; + background: transparent; +} +.book.color-theme-2 .book-header .btn { + color: #3b3f54; +} +.book.color-theme-2 .book-header .btn:hover { + color: #fffff5; + background: none; +} +.book.color-theme-2 .book-header h1 { + color: #bdcadb; +} +.book.color-theme-1 .book-body .navigation { + color: #afa790; +} +.book.color-theme-1 .book-body .navigation:hover { + color: #73553c; +} +.book.color-theme-2 .book-body .navigation { + color: #383f52; +} +.book.color-theme-2 .book-body .navigation:hover { + color: #fffff5; +} +/* + * Theme 1 + */ +.book.color-theme-1 .book-summary { + color: #afa790; + background: #111111; + border-right: 1px solid rgba(0, 0, 0, 0.07); +} +.book.color-theme-1 .book-summary .book-search { + background: transparent; +} +.book.color-theme-1 .book-summary .book-search input, +.book.color-theme-1 .book-summary .book-search input:focus { + border: 1px solid transparent; +} +.book.color-theme-1 .book-summary ul.summary li.divider { + background: #7e888b; + box-shadow: none; +} +.book.color-theme-1 .book-summary ul.summary li i.fa-check { + color: #33cc33; +} +.book.color-theme-1 .book-summary ul.summary li.done > a { + color: #877f6a; +} +.book.color-theme-1 .book-summary ul.summary li a, +.book.color-theme-1 .book-summary ul.summary li span { + color: #877f6a; + background: transparent; + font-weight: normal; +} +.book.color-theme-1 .book-summary ul.summary li.active > a, +.book.color-theme-1 .book-summary ul.summary li a:hover { + color: #704214; + background: transparent; + font-weight: normal; +} +/* + * Theme 2 + */ +.book.color-theme-2 .book-summary { + color: #bcc1d2; + background: #2d3143; + border-right: none; +} +.book.color-theme-2 .book-summary .book-search { + background: transparent; +} +.book.color-theme-2 .book-summary .book-search input, +.book.color-theme-2 .book-summary .book-search input:focus { + border: 1px solid transparent; +} +.book.color-theme-2 .book-summary ul.summary li.divider { + background: #272a3a; + box-shadow: none; +} +.book.color-theme-2 .book-summary ul.summary li i.fa-check { + color: #33cc33; +} +.book.color-theme-2 .book-summary ul.summary li.done > a { + color: #62687f; +} +.book.color-theme-2 .book-summary ul.summary li a, +.book.color-theme-2 .book-summary ul.summary li span { + color: #c1c6d7; + background: transparent; + font-weight: 600; +} +.book.color-theme-2 .book-summary ul.summary li.active > a, +.book.color-theme-2 .book-summary ul.summary li a:hover { + color: #f4f4f5; + background: #252737; + font-weight: 600; +} diff --git a/docs/book/gitbook/gitbook-plugin-highlight/ebook.css b/docs/book/gitbook/gitbook-plugin-highlight/ebook.css new file mode 100644 index 000000000..cecaaab5a --- /dev/null +++ b/docs/book/gitbook/gitbook-plugin-highlight/ebook.css @@ -0,0 +1,135 @@ +pre, +code { + /* http://jmblog.github.io/color-themes-for-highlightjs */ + /* Tomorrow Comment */ + /* Tomorrow Red */ + /* Tomorrow Orange */ + /* Tomorrow Yellow */ + /* Tomorrow Green */ + /* Tomorrow Aqua */ + /* Tomorrow Blue */ + /* Tomorrow Purple */ +} +pre .hljs-comment, +code .hljs-comment, +pre .hljs-title, +code .hljs-title { + color: #8e908c; +} +pre .hljs-variable, +code .hljs-variable, +pre .hljs-attribute, +code .hljs-attribute, +pre .hljs-tag, +code .hljs-tag, +pre .hljs-regexp, +code .hljs-regexp, +pre .hljs-deletion, +code .hljs-deletion, +pre .ruby .hljs-constant, +code .ruby .hljs-constant, +pre .xml .hljs-tag .hljs-title, +code .xml .hljs-tag .hljs-title, +pre .xml .hljs-pi, +code .xml .hljs-pi, +pre .xml .hljs-doctype, +code .xml .hljs-doctype, +pre .html .hljs-doctype, +code .html .hljs-doctype, +pre .css .hljs-id, +code .css .hljs-id, +pre .css .hljs-class, +code .css .hljs-class, +pre .css .hljs-pseudo, +code .css .hljs-pseudo { + color: #c82829; +} +pre .hljs-number, +code .hljs-number, +pre .hljs-preprocessor, +code .hljs-preprocessor, +pre .hljs-pragma, +code .hljs-pragma, +pre .hljs-built_in, +code .hljs-built_in, +pre .hljs-literal, +code .hljs-literal, +pre .hljs-params, +code .hljs-params, +pre .hljs-constant, +code .hljs-constant { + color: #f5871f; +} +pre .ruby .hljs-class .hljs-title, +code .ruby .hljs-class .hljs-title, +pre .css .hljs-rules .hljs-attribute, +code .css .hljs-rules .hljs-attribute { + color: #eab700; +} +pre .hljs-string, +code .hljs-string, +pre .hljs-value, +code .hljs-value, +pre .hljs-inheritance, +code .hljs-inheritance, +pre .hljs-header, +code .hljs-header, +pre .hljs-addition, +code .hljs-addition, +pre .ruby .hljs-symbol, +code .ruby .hljs-symbol, +pre .xml .hljs-cdata, +code .xml .hljs-cdata { + color: #718c00; +} +pre .css .hljs-hexcolor, +code .css .hljs-hexcolor { + color: #3e999f; +} +pre .hljs-function, +code .hljs-function, +pre .python .hljs-decorator, +code .python .hljs-decorator, +pre .python .hljs-title, +code .python .hljs-title, +pre .ruby .hljs-function .hljs-title, +code .ruby .hljs-function .hljs-title, +pre .ruby .hljs-title .hljs-keyword, +code .ruby .hljs-title .hljs-keyword, +pre .perl .hljs-sub, +code .perl .hljs-sub, +pre .javascript .hljs-title, +code .javascript .hljs-title, +pre .coffeescript .hljs-title, +code .coffeescript .hljs-title { + color: #4271ae; +} +pre .hljs-keyword, +code .hljs-keyword, +pre .javascript .hljs-function, +code .javascript .hljs-function { + color: #8959a8; +} +pre .hljs, +code .hljs { + display: block; + background: white; + color: #4d4d4c; + padding: 0.5em; +} +pre .coffeescript .javascript, +code .coffeescript .javascript, +pre .javascript .xml, +code .javascript .xml, +pre .tex .hljs-formula, +code .tex .hljs-formula, +pre .xml .javascript, +code .xml .javascript, +pre .xml .vbscript, +code .xml .vbscript, +pre .xml .css, +code .xml .css, +pre .xml .hljs-cdata, +code .xml .hljs-cdata { + opacity: 0.5; +} diff --git a/docs/book/gitbook/gitbook-plugin-highlight/website.css b/docs/book/gitbook/gitbook-plugin-highlight/website.css new file mode 100644 index 000000000..6674448f7 --- /dev/null +++ b/docs/book/gitbook/gitbook-plugin-highlight/website.css @@ -0,0 +1,434 @@ +.book .book-body .page-wrapper .page-inner section.normal pre, +.book .book-body .page-wrapper .page-inner section.normal code { + /* http://jmblog.github.com/color-themes-for-google-code-highlightjs */ + /* Tomorrow Comment */ + /* Tomorrow Red */ + /* Tomorrow Orange */ + /* Tomorrow Yellow */ + /* Tomorrow Green */ + /* Tomorrow Aqua */ + /* Tomorrow Blue */ + /* Tomorrow Purple */ +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-comment, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-comment, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-title { + color: #8e908c; +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-variable, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-variable, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-attribute, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-attribute, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-tag, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-tag, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-regexp, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-regexp, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-deletion, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-deletion, +.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-constant, +.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-constant, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-tag .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-tag .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-pi, +.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-pi, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-doctype, +.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-doctype, +.book .book-body .page-wrapper .page-inner section.normal pre .html .hljs-doctype, +.book .book-body .page-wrapper .page-inner section.normal code .html .hljs-doctype, +.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-id, +.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-id, +.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-class, +.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-class, +.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-pseudo, +.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-pseudo { + color: #c82829; +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-number, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-number, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-pragma, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-pragma, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-built_in, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-built_in, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-literal, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-literal, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-params, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-params, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-constant, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-constant { + color: #f5871f; +} +.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-class .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-class .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-rules .hljs-attribute, +.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-rules .hljs-attribute { + color: #eab700; +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-string, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-string, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-value, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-value, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-inheritance, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-inheritance, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-header, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-header, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-addition, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-addition, +.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-symbol, +.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-symbol, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, +.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { + color: #718c00; +} +.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-hexcolor, +.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-hexcolor { + color: #3e999f; +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-function, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-function, +.book .book-body .page-wrapper .page-inner section.normal pre .python .hljs-decorator, +.book .book-body .page-wrapper .page-inner section.normal code .python .hljs-decorator, +.book .book-body .page-wrapper .page-inner section.normal pre .python .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .python .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-function .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-function .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-title .hljs-keyword, +.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-title .hljs-keyword, +.book .book-body .page-wrapper .page-inner section.normal pre .perl .hljs-sub, +.book .book-body .page-wrapper .page-inner section.normal code .perl .hljs-sub, +.book .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal pre .coffeescript .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .coffeescript .hljs-title { + color: #4271ae; +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-keyword, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-keyword, +.book .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-function, +.book .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-function { + color: #8959a8; +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs, +.book .book-body .page-wrapper .page-inner section.normal code .hljs { + display: block; + background: white; + color: #4d4d4c; + padding: 0.5em; +} +.book .book-body .page-wrapper .page-inner section.normal pre .coffeescript .javascript, +.book .book-body .page-wrapper .page-inner section.normal code .coffeescript .javascript, +.book .book-body .page-wrapper .page-inner section.normal pre .javascript .xml, +.book .book-body .page-wrapper .page-inner section.normal code .javascript .xml, +.book .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, +.book .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .javascript, +.book .book-body .page-wrapper .page-inner section.normal code .xml .javascript, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .vbscript, +.book .book-body .page-wrapper .page-inner section.normal code .xml .vbscript, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .css, +.book .book-body .page-wrapper .page-inner section.normal code .xml .css, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, +.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { + opacity: 0.5; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code { + /* + +Orginal Style from ethanschoonover.com/solarized (c) Jeremy Hull + +*/ + /* Solarized Green */ + /* Solarized Cyan */ + /* Solarized Blue */ + /* Solarized Yellow */ + /* Solarized Orange */ + /* Solarized Red */ + /* Solarized Violet */ +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs { + display: block; + padding: 0.5em; + background: #fdf6e3; + color: #657b83; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-comment, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-comment, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-template_comment, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-template_comment, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .diff .hljs-header, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .diff .hljs-header, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-doctype, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-doctype, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-pi, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-pi, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .lisp .hljs-string, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .lisp .hljs-string, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-javadoc, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-javadoc { + color: #93a1a1; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-keyword, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-keyword, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-winutils, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-winutils, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .method, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .method, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-addition, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-addition, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-tag, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .css .hljs-tag, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-request, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-request, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-status, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-status, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .nginx .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .nginx .hljs-title { + color: #859900; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-number, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-number, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-command, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-command, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-string, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-string, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-tag .hljs-value, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-tag .hljs-value, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-rules .hljs-value, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-rules .hljs-value, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-phpdoc, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-phpdoc, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-regexp, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-regexp, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-hexcolor, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-hexcolor, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-link_url, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-link_url { + color: #2aa198; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-localvars, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-localvars, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-chunk, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-chunk, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-decorator, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-decorator, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-built_in, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-built_in, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-identifier, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-identifier, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .vhdl .hljs-literal, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .vhdl .hljs-literal, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-id, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-id, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-function, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .css .hljs-function { + color: #268bd2; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-attribute, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-attribute, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-variable, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-variable, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .lisp .hljs-body, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .lisp .hljs-body, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .smalltalk .hljs-number, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .smalltalk .hljs-number, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-constant, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-constant, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-class .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-class .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-parent, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-parent, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .haskell .hljs-type, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .haskell .hljs-type, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-link_reference, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-link_reference { + color: #b58900; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor .hljs-keyword, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor .hljs-keyword, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-pragma, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-pragma, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-shebang, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-shebang, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-symbol, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-symbol, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-symbol .hljs-string, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-symbol .hljs-string, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .diff .hljs-change, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .diff .hljs-change, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-special, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-special, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-attr_selector, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-attr_selector, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-subst, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-subst, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-cdata, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-cdata, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .clojure .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .clojure .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-pseudo, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .css .hljs-pseudo, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-header, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-header { + color: #cb4b16; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-deletion, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-deletion, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-important, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-important { + color: #dc322f; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-link_label, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-link_label { + color: #6c71c4; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula { + background: #eee8d5; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code { + /* Tomorrow Night Bright Theme */ + /* Original theme - https://github.com/chriskempson/tomorrow-theme */ + /* http://jmblog.github.com/color-themes-for-google-code-highlightjs */ + /* Tomorrow Comment */ + /* Tomorrow Red */ + /* Tomorrow Orange */ + /* Tomorrow Yellow */ + /* Tomorrow Green */ + /* Tomorrow Aqua */ + /* Tomorrow Blue */ + /* Tomorrow Purple */ +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-comment, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-comment, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-title { + color: #969896; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-variable, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-variable, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-attribute, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-attribute, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-tag, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-tag, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-regexp, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-regexp, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-deletion, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-deletion, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-constant, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-constant, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-tag .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-tag .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-pi, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-pi, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-doctype, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-doctype, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .html .hljs-doctype, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .html .hljs-doctype, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-id, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-id, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-class, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-class, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-pseudo, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-pseudo { + color: #d54e53; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-number, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-number, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-pragma, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-pragma, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-built_in, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-built_in, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-literal, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-literal, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-params, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-params, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-constant, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-constant { + color: #e78c45; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-class .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-class .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-rules .hljs-attribute, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-rules .hljs-attribute { + color: #e7c547; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-string, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-string, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-value, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-value, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-inheritance, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-inheritance, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-header, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-header, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-addition, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-addition, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-symbol, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-symbol, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { + color: #b9ca4a; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-hexcolor, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-hexcolor { + color: #70c0b1; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-function, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-function, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .python .hljs-decorator, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .python .hljs-decorator, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .python .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .python .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-function .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-function .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-title .hljs-keyword, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-title .hljs-keyword, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .perl .hljs-sub, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .perl .hljs-sub, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .coffeescript .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .coffeescript .hljs-title { + color: #7aa6da; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-keyword, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-keyword, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-function, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-function { + color: #c397d8; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs { + display: block; + background: black; + color: #eaeaea; + padding: 0.5em; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .coffeescript .javascript, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .coffeescript .javascript, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .javascript .xml, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .javascript .xml, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .javascript, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .javascript, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .vbscript, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .vbscript, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .css, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .css, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { + opacity: 0.5; +} diff --git a/docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js b/docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js new file mode 100644 index 000000000..6aa6bc7d6 --- /dev/null +++ b/docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js @@ -0,0 +1,7 @@ +/** + * lunr - http://lunrjs.com - A bit like Solr, but much smaller and not as bright - 0.5.12 + * Copyright (C) 2015 Oliver Nightingale + * MIT Licensed + * @license + */ +!function(){var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.5.12",t.utils={},t.utils.warn=function(t){return function(e){t.console&&console.warn&&console.warn(e)}}(this),t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var t=Array.prototype.slice.call(arguments),e=t.pop(),n=t;if("function"!=typeof e)throw new TypeError("last argument must be a function");n.forEach(function(t){this.hasHandler(t)||(this.events[t]=[]),this.events[t].push(e)},this)},t.EventEmitter.prototype.removeListener=function(t,e){if(this.hasHandler(t)){var n=this.events[t].indexOf(e);this.events[t].splice(n,1),this.events[t].length||delete this.events[t]}},t.EventEmitter.prototype.emit=function(t){if(this.hasHandler(t)){var e=Array.prototype.slice.call(arguments,1);this.events[t].forEach(function(t){t.apply(void 0,e)})}},t.EventEmitter.prototype.hasHandler=function(t){return t in this.events},t.tokenizer=function(t){return arguments.length&&null!=t&&void 0!=t?Array.isArray(t)?t.map(function(t){return t.toLowerCase()}):t.toString().trim().toLowerCase().split(/[\s\-]+/):[]},t.Pipeline=function(){this._stack=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in this.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[e.label]=e},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.registeredFunctions[e];if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._stack.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._stack.indexOf(e);if(-1==i)throw new Error("Cannot find existingFn");i+=1,this._stack.splice(i,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._stack.indexOf(e);if(-1==i)throw new Error("Cannot find existingFn");this._stack.splice(i,0,n)},t.Pipeline.prototype.remove=function(t){var e=this._stack.indexOf(t);-1!=e&&this._stack.splice(e,1)},t.Pipeline.prototype.run=function(t){for(var e=[],n=t.length,i=this._stack.length,o=0;n>o;o++){for(var r=t[o],s=0;i>s&&(r=this._stack[s](r,o,t),void 0!==r);s++);void 0!==r&&e.push(r)}return e},t.Pipeline.prototype.reset=function(){this._stack=[]},t.Pipeline.prototype.toJSON=function(){return this._stack.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Vector=function(){this._magnitude=null,this.list=void 0,this.length=0},t.Vector.Node=function(t,e,n){this.idx=t,this.val=e,this.next=n},t.Vector.prototype.insert=function(e,n){this._magnitude=void 0;var i=this.list;if(!i)return this.list=new t.Vector.Node(e,n,i),this.length++;if(en.idx?n=n.next:(i+=e.val*n.val,e=e.next,n=n.next);return i},t.Vector.prototype.similarity=function(t){return this.dot(t)/(this.magnitude()*t.magnitude())},t.SortedSet=function(){this.length=0,this.elements=[]},t.SortedSet.load=function(t){var e=new this;return e.elements=t,e.length=t.length,e},t.SortedSet.prototype.add=function(){var t,e;for(t=0;t1;){if(r===t)return o;t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o]}return r===t?o:-1},t.SortedSet.prototype.locationFor=function(t){for(var e=0,n=this.elements.length,i=n-e,o=e+Math.floor(i/2),r=this.elements[o];i>1;)t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o];return r>t?o:t>r?o+1:void 0},t.SortedSet.prototype.intersect=function(e){for(var n=new t.SortedSet,i=0,o=0,r=this.length,s=e.length,a=this.elements,h=e.elements;;){if(i>r-1||o>s-1)break;a[i]!==h[o]?a[i]h[o]&&o++:(n.add(a[i]),i++,o++)}return n},t.SortedSet.prototype.clone=function(){var e=new t.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},t.SortedSet.prototype.union=function(t){var e,n,i;return this.length>=t.length?(e=this,n=t):(e=t,n=this),i=e.clone(),i.add.apply(i,n.toArray()),i},t.SortedSet.prototype.toJSON=function(){return this.toArray()},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.Store,this.tokenStore=new t.TokenStore,this.corpusTokens=new t.SortedSet,this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var t=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,t)},t.Index.prototype.off=function(t,e){return this.eventEmitter.removeListener(t,e)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;return n._fields=e.fields,n._ref=e.ref,n.documentStore=t.Store.load(e.documentStore),n.tokenStore=t.TokenStore.load(e.tokenStore),n.corpusTokens=t.SortedSet.load(e.corpusTokens),n.pipeline=t.Pipeline.load(e.pipeline),n},t.Index.prototype.field=function(t,e){var e=e||{},n={name:t,boost:e.boost||1};return this._fields.push(n),this},t.Index.prototype.ref=function(t){return this._ref=t,this},t.Index.prototype.add=function(e,n){var i={},o=new t.SortedSet,r=e[this._ref],n=void 0===n?!0:n;this._fields.forEach(function(n){var r=this.pipeline.run(t.tokenizer(e[n.name]));i[n.name]=r,t.SortedSet.prototype.add.apply(o,r)},this),this.documentStore.set(r,o),t.SortedSet.prototype.add.apply(this.corpusTokens,o.toArray());for(var s=0;s0&&(i=1+Math.log(this.documentStore.length/n)),this._idfCache[e]=i},t.Index.prototype.search=function(e){var n=this.pipeline.run(t.tokenizer(e)),i=new t.Vector,o=[],r=this._fields.reduce(function(t,e){return t+e.boost},0),s=n.some(function(t){return this.tokenStore.has(t)},this);if(!s)return[];n.forEach(function(e,n,s){var a=1/s.length*this._fields.length*r,h=this,l=this.tokenStore.expand(e).reduce(function(n,o){var r=h.corpusTokens.indexOf(o),s=h.idf(o),l=1,u=new t.SortedSet;if(o!==e){var c=Math.max(3,o.length-e.length);l=1/Math.log(c)}return r>-1&&i.insert(r,a*s*l),Object.keys(h.tokenStore.get(o)).forEach(function(t){u.add(t)}),n.union(u)},new t.SortedSet);o.push(l)},this);var a=o.reduce(function(t,e){return t.intersect(e)});return a.map(function(t){return{ref:t,score:i.similarity(this.documentVector(t))}},this).sort(function(t,e){return e.score-t.score})},t.Index.prototype.documentVector=function(e){for(var n=this.documentStore.get(e),i=n.length,o=new t.Vector,r=0;i>r;r++){var s=n.elements[r],a=this.tokenStore.get(s)[e].tf,h=this.idf(s);o.insert(this.corpusTokens.indexOf(s),a*h)}return o},t.Index.prototype.toJSON=function(){return{version:t.version,fields:this._fields,ref:this._ref,documentStore:this.documentStore.toJSON(),tokenStore:this.tokenStore.toJSON(),corpusTokens:this.corpusTokens.toJSON(),pipeline:this.pipeline.toJSON()}},t.Index.prototype.use=function(t){var e=Array.prototype.slice.call(arguments,1);e.unshift(this),t.apply(this,e)},t.Store=function(){this.store={},this.length=0},t.Store.load=function(e){var n=new this;return n.length=e.length,n.store=Object.keys(e.store).reduce(function(n,i){return n[i]=t.SortedSet.load(e.store[i]),n},{}),n},t.Store.prototype.set=function(t,e){this.has(t)||this.length++,this.store[t]=e},t.Store.prototype.get=function(t){return this.store[t]},t.Store.prototype.has=function(t){return t in this.store},t.Store.prototype.remove=function(t){this.has(t)&&(delete this.store[t],this.length--)},t.Store.prototype.toJSON=function(){return{store:this.store,length:this.length}},t.stemmer=function(){var t={ational:"ate",tional:"tion",enci:"ence",anci:"ance",izer:"ize",bli:"ble",alli:"al",entli:"ent",eli:"e",ousli:"ous",ization:"ize",ation:"ate",ator:"ate",alism:"al",iveness:"ive",fulness:"ful",ousness:"ous",aliti:"al",iviti:"ive",biliti:"ble",logi:"log"},e={icate:"ic",ative:"",alize:"al",iciti:"ic",ical:"ic",ful:"",ness:""},n="[^aeiou]",i="[aeiouy]",o=n+"[^aeiouy]*",r=i+"[aeiou]*",s="^("+o+")?"+r+o,a="^("+o+")?"+r+o+"("+r+")?$",h="^("+o+")?"+r+o+r+o,l="^("+o+")?"+i,u=new RegExp(s),c=new RegExp(h),f=new RegExp(a),d=new RegExp(l),p=/^(.+?)(ss|i)es$/,m=/^(.+?)([^s])s$/,v=/^(.+?)eed$/,y=/^(.+?)(ed|ing)$/,g=/.$/,S=/(at|bl|iz)$/,w=new RegExp("([^aeiouylsz])\\1$"),x=new RegExp("^"+o+i+"[^aeiouwxy]$"),k=/^(.+?[^aeiou])y$/,b=/^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/,E=/^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/,_=/^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/,F=/^(.+?)(s|t)(ion)$/,O=/^(.+?)e$/,P=/ll$/,N=new RegExp("^"+o+i+"[^aeiouwxy]$"),T=function(n){var i,o,r,s,a,h,l;if(n.length<3)return n;if(r=n.substr(0,1),"y"==r&&(n=r.toUpperCase()+n.substr(1)),s=p,a=m,s.test(n)?n=n.replace(s,"$1$2"):a.test(n)&&(n=n.replace(a,"$1$2")),s=v,a=y,s.test(n)){var T=s.exec(n);s=u,s.test(T[1])&&(s=g,n=n.replace(s,""))}else if(a.test(n)){var T=a.exec(n);i=T[1],a=d,a.test(i)&&(n=i,a=S,h=w,l=x,a.test(n)?n+="e":h.test(n)?(s=g,n=n.replace(s,"")):l.test(n)&&(n+="e"))}if(s=k,s.test(n)){var T=s.exec(n);i=T[1],n=i+"i"}if(s=b,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+t[o])}if(s=E,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+e[o])}if(s=_,a=F,s.test(n)){var T=s.exec(n);i=T[1],s=c,s.test(i)&&(n=i)}else if(a.test(n)){var T=a.exec(n);i=T[1]+T[2],a=c,a.test(i)&&(n=i)}if(s=O,s.test(n)){var T=s.exec(n);i=T[1],s=c,a=f,h=N,(s.test(i)||a.test(i)&&!h.test(i))&&(n=i)}return s=P,a=c,s.test(n)&&a.test(n)&&(s=g,n=n.replace(s,"")),"y"==r&&(n=r.toLowerCase()+n.substr(1)),n};return T}(),t.Pipeline.registerFunction(t.stemmer,"stemmer"),t.stopWordFilter=function(e){return e&&t.stopWordFilter.stopWords[e]!==e?e:void 0},t.stopWordFilter.stopWords={a:"a",able:"able",about:"about",across:"across",after:"after",all:"all",almost:"almost",also:"also",am:"am",among:"among",an:"an",and:"and",any:"any",are:"are",as:"as",at:"at",be:"be",because:"because",been:"been",but:"but",by:"by",can:"can",cannot:"cannot",could:"could",dear:"dear",did:"did","do":"do",does:"does",either:"either","else":"else",ever:"ever",every:"every","for":"for",from:"from",get:"get",got:"got",had:"had",has:"has",have:"have",he:"he",her:"her",hers:"hers",him:"him",his:"his",how:"how",however:"however",i:"i","if":"if","in":"in",into:"into",is:"is",it:"it",its:"its",just:"just",least:"least",let:"let",like:"like",likely:"likely",may:"may",me:"me",might:"might",most:"most",must:"must",my:"my",neither:"neither",no:"no",nor:"nor",not:"not",of:"of",off:"off",often:"often",on:"on",only:"only",or:"or",other:"other",our:"our",own:"own",rather:"rather",said:"said",say:"say",says:"says",she:"she",should:"should",since:"since",so:"so",some:"some",than:"than",that:"that",the:"the",their:"their",them:"them",then:"then",there:"there",these:"these",they:"they","this":"this",tis:"tis",to:"to",too:"too",twas:"twas",us:"us",wants:"wants",was:"was",we:"we",were:"were",what:"what",when:"when",where:"where",which:"which","while":"while",who:"who",whom:"whom",why:"why",will:"will","with":"with",would:"would",yet:"yet",you:"you",your:"your"},t.Pipeline.registerFunction(t.stopWordFilter,"stopWordFilter"),t.trimmer=function(t){var e=t.replace(/^\W+/,"").replace(/\W+$/,"");return""===e?void 0:e},t.Pipeline.registerFunction(t.trimmer,"trimmer"),t.TokenStore=function(){this.root={docs:{}},this.length=0},t.TokenStore.load=function(t){var e=new this;return e.root=t.root,e.length=t.length,e},t.TokenStore.prototype.add=function(t,e,n){var n=n||this.root,i=t[0],o=t.slice(1);return i in n||(n[i]={docs:{}}),0===o.length?(n[i].docs[e.ref]=e,void(this.length+=1)):this.add(o,e,n[i])},t.TokenStore.prototype.has=function(t){if(!t)return!1;for(var e=this.root,n=0;no;o++){for(var r=t[o],s=0;i>s&&(r=this._stack[s](r,o,t),void 0!==r);s++);void 0!==r&&e.push(r)}return e},t.Pipeline.prototype.reset=function(){this._stack=[]},t.Pipeline.prototype.toJSON=function(){return this._stack.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Vector=function(){this._magnitude=null,this.list=void 0,this.length=0},t.Vector.Node=function(t,e,n){this.idx=t,this.val=e,this.next=n},t.Vector.prototype.insert=function(e,n){this._magnitude=void 0;var i=this.list;if(!i)return this.list=new t.Vector.Node(e,n,i),this.length++;if(en.idx?n=n.next:(i+=e.val*n.val,e=e.next,n=n.next);return i},t.Vector.prototype.similarity=function(t){return this.dot(t)/(this.magnitude()*t.magnitude())},t.SortedSet=function(){this.length=0,this.elements=[]},t.SortedSet.load=function(t){var e=new this;return e.elements=t,e.length=t.length,e},t.SortedSet.prototype.add=function(){var t,e;for(t=0;t1;){if(r===t)return o;t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o]}return r===t?o:-1},t.SortedSet.prototype.locationFor=function(t){for(var e=0,n=this.elements.length,i=n-e,o=e+Math.floor(i/2),r=this.elements[o];i>1;)t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o];return r>t?o:t>r?o+1:void 0},t.SortedSet.prototype.intersect=function(e){for(var n=new t.SortedSet,i=0,o=0,r=this.length,s=e.length,a=this.elements,h=e.elements;;){if(i>r-1||o>s-1)break;a[i]!==h[o]?a[i]h[o]&&o++:(n.add(a[i]),i++,o++)}return n},t.SortedSet.prototype.clone=function(){var e=new t.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},t.SortedSet.prototype.union=function(t){var e,n,i;return this.length>=t.length?(e=this,n=t):(e=t,n=this),i=e.clone(),i.add.apply(i,n.toArray()),i},t.SortedSet.prototype.toJSON=function(){return this.toArray()},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.Store,this.tokenStore=new t.TokenStore,this.corpusTokens=new t.SortedSet,this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var t=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,t)},t.Index.prototype.off=function(t,e){return this.eventEmitter.removeListener(t,e)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;return n._fields=e.fields,n._ref=e.ref,n.documentStore=t.Store.load(e.documentStore),n.tokenStore=t.TokenStore.load(e.tokenStore),n.corpusTokens=t.SortedSet.load(e.corpusTokens),n.pipeline=t.Pipeline.load(e.pipeline),n},t.Index.prototype.field=function(t,e){var e=e||{},n={name:t,boost:e.boost||1};return this._fields.push(n),this},t.Index.prototype.ref=function(t){return this._ref=t,this},t.Index.prototype.add=function(e,n){var i={},o=new t.SortedSet,r=e[this._ref],n=void 0===n?!0:n;this._fields.forEach(function(n){var r=this.pipeline.run(t.tokenizer(e[n.name]));i[n.name]=r,t.SortedSet.prototype.add.apply(o,r)},this),this.documentStore.set(r,o),t.SortedSet.prototype.add.apply(this.corpusTokens,o.toArray());for(var s=0;s0&&(i=1+Math.log(this.documentStore.length/n)),this._idfCache[e]=i},t.Index.prototype.search=function(e){var n=this.pipeline.run(t.tokenizer(e)),i=new t.Vector,o=[],r=this._fields.reduce(function(t,e){return t+e.boost},0),s=n.some(function(t){return this.tokenStore.has(t)},this);if(!s)return[];n.forEach(function(e,n,s){var a=1/s.length*this._fields.length*r,h=this,l=this.tokenStore.expand(e).reduce(function(n,o){var r=h.corpusTokens.indexOf(o),s=h.idf(o),l=1,u=new t.SortedSet;if(o!==e){var c=Math.max(3,o.length-e.length);l=1/Math.log(c)}return r>-1&&i.insert(r,a*s*l),Object.keys(h.tokenStore.get(o)).forEach(function(t){u.add(t)}),n.union(u)},new t.SortedSet);o.push(l)},this);var a=o.reduce(function(t,e){return t.intersect(e)});return a.map(function(t){return{ref:t,score:i.similarity(this.documentVector(t))}},this).sort(function(t,e){return e.score-t.score})},t.Index.prototype.documentVector=function(e){for(var n=this.documentStore.get(e),i=n.length,o=new t.Vector,r=0;i>r;r++){var s=n.elements[r],a=this.tokenStore.get(s)[e].tf,h=this.idf(s);o.insert(this.corpusTokens.indexOf(s),a*h)}return o},t.Index.prototype.toJSON=function(){return{version:t.version,fields:this._fields,ref:this._ref,documentStore:this.documentStore.toJSON(),tokenStore:this.tokenStore.toJSON(),corpusTokens:this.corpusTokens.toJSON(),pipeline:this.pipeline.toJSON()}},t.Index.prototype.use=function(t){var e=Array.prototype.slice.call(arguments,1);e.unshift(this),t.apply(this,e)},t.Store=function(){this.store={},this.length=0},t.Store.load=function(e){var n=new this;return n.length=e.length,n.store=Object.keys(e.store).reduce(function(n,i){return n[i]=t.SortedSet.load(e.store[i]),n},{}),n},t.Store.prototype.set=function(t,e){this.has(t)||this.length++,this.store[t]=e},t.Store.prototype.get=function(t){return this.store[t]},t.Store.prototype.has=function(t){return t in this.store},t.Store.prototype.remove=function(t){this.has(t)&&(delete this.store[t],this.length--)},t.Store.prototype.toJSON=function(){return{store:this.store,length:this.length}},t.stemmer=function(){var t={ational:"ate",tional:"tion",enci:"ence",anci:"ance",izer:"ize",bli:"ble",alli:"al",entli:"ent",eli:"e",ousli:"ous",ization:"ize",ation:"ate",ator:"ate",alism:"al",iveness:"ive",fulness:"ful",ousness:"ous",aliti:"al",iviti:"ive",biliti:"ble",logi:"log"},e={icate:"ic",ative:"",alize:"al",iciti:"ic",ical:"ic",ful:"",ness:""},n="[^aeiou]",i="[aeiouy]",o=n+"[^aeiouy]*",r=i+"[aeiou]*",s="^("+o+")?"+r+o,a="^("+o+")?"+r+o+"("+r+")?$",h="^("+o+")?"+r+o+r+o,l="^("+o+")?"+i,u=new RegExp(s),c=new RegExp(h),f=new RegExp(a),d=new RegExp(l),p=/^(.+?)(ss|i)es$/,m=/^(.+?)([^s])s$/,v=/^(.+?)eed$/,y=/^(.+?)(ed|ing)$/,g=/.$/,S=/(at|bl|iz)$/,w=new RegExp("([^aeiouylsz])\\1$"),x=new RegExp("^"+o+i+"[^aeiouwxy]$"),k=/^(.+?[^aeiou])y$/,b=/^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/,E=/^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/,_=/^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/,F=/^(.+?)(s|t)(ion)$/,O=/^(.+?)e$/,P=/ll$/,N=new RegExp("^"+o+i+"[^aeiouwxy]$"),T=function(n){var i,o,r,s,a,h,l;if(n.length<3)return n;if(r=n.substr(0,1),"y"==r&&(n=r.toUpperCase()+n.substr(1)),s=p,a=m,s.test(n)?n=n.replace(s,"$1$2"):a.test(n)&&(n=n.replace(a,"$1$2")),s=v,a=y,s.test(n)){var T=s.exec(n);s=u,s.test(T[1])&&(s=g,n=n.replace(s,""))}else if(a.test(n)){var T=a.exec(n);i=T[1],a=d,a.test(i)&&(n=i,a=S,h=w,l=x,a.test(n)?n+="e":h.test(n)?(s=g,n=n.replace(s,"")):l.test(n)&&(n+="e"))}if(s=k,s.test(n)){var T=s.exec(n);i=T[1],n=i+"i"}if(s=b,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+t[o])}if(s=E,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+e[o])}if(s=_,a=F,s.test(n)){var T=s.exec(n);i=T[1],s=c,s.test(i)&&(n=i)}else if(a.test(n)){var T=a.exec(n);i=T[1]+T[2],a=c,a.test(i)&&(n=i)}if(s=O,s.test(n)){var T=s.exec(n);i=T[1],s=c,a=f,h=N,(s.test(i)||a.test(i)&&!h.test(i))&&(n=i)}return s=P,a=c,s.test(n)&&a.test(n)&&(s=g,n=n.replace(s,"")),"y"==r&&(n=r.toLowerCase()+n.substr(1)),n};return T}(),t.Pipeline.registerFunction(t.stemmer,"stemmer"),t.stopWordFilter=function(e){return e&&t.stopWordFilter.stopWords[e]!==e?e:void 0},t.stopWordFilter.stopWords={a:"a",able:"able",about:"about",across:"across",after:"after",all:"all",almost:"almost",also:"also",am:"am",among:"among",an:"an",and:"and",any:"any",are:"are",as:"as",at:"at",be:"be",because:"because",been:"been",but:"but",by:"by",can:"can",cannot:"cannot",could:"could",dear:"dear",did:"did","do":"do",does:"does",either:"either","else":"else",ever:"ever",every:"every","for":"for",from:"from",get:"get",got:"got",had:"had",has:"has",have:"have",he:"he",her:"her",hers:"hers",him:"him",his:"his",how:"how",however:"however",i:"i","if":"if","in":"in",into:"into",is:"is",it:"it",its:"its",just:"just",least:"least",let:"let",like:"like",likely:"likely",may:"may",me:"me",might:"might",most:"most",must:"must",my:"my",neither:"neither",no:"no",nor:"nor",not:"not",of:"of",off:"off",often:"often",on:"on",only:"only",or:"or",other:"other",our:"our",own:"own",rather:"rather",said:"said",say:"say",says:"says",she:"she",should:"should",since:"since",so:"so",some:"some",than:"than",that:"that",the:"the",their:"their",them:"them",then:"then",there:"there",these:"these",they:"they","this":"this",tis:"tis",to:"to",too:"too",twas:"twas",us:"us",wants:"wants",was:"was",we:"we",were:"were",what:"what",when:"when",where:"where",which:"which","while":"while",who:"who",whom:"whom",why:"why",will:"will","with":"with",would:"would",yet:"yet",you:"you",your:"your"},t.Pipeline.registerFunction(t.stopWordFilter,"stopWordFilter"),t.trimmer=function(t){var e=t.replace(/^\W+/,"").replace(/\W+$/,"");return""===e?void 0:e},t.Pipeline.registerFunction(t.trimmer,"trimmer"),t.TokenStore=function(){this.root={docs:{}},this.length=0},t.TokenStore.load=function(t){var e=new this;return e.root=t.root,e.length=t.length,e},t.TokenStore.prototype.add=function(t,e,n){var n=n||this.root,i=t[0],o=t.slice(1);return i in n||(n[i]={docs:{}}),0===o.length?(n[i].docs[e.ref]=e,void(this.length+=1)):this.add(o,e,n[i])},t.TokenStore.prototype.has=function(t){if(!t)return!1;for(var e=this.root,n=0;n element for each result + res.results.forEach(function(res) { + var $li = $('

              • ', { + 'class': 'search-results-item' + }); + + var $title = $('

                '); + + var $link = $('', { + 'href': gitbook.state.basePath + '/' + res.url, + 'text': res.title + }); + + var content = res.body.trim(); + if (content.length > MAX_DESCRIPTION_SIZE) { + content = content.slice(0, MAX_DESCRIPTION_SIZE).trim()+'...'; + } + var $content = $('

                ').html(content); + + $link.appendTo($title); + $title.appendTo($li); + $content.appendTo($li); + $li.appendTo($searchList); + }); + } + + function launchSearch(q) { + // Add class for loading + $body.addClass('with-search'); + $body.addClass('search-loading'); + + // Launch search query + throttle(gitbook.search.query(q, 0, MAX_RESULTS) + .then(function(results) { + displayResults(results); + }) + .always(function() { + $body.removeClass('search-loading'); + }), 1000); + } + + function closeSearch() { + $body.removeClass('with-search'); + $bookSearchResults.removeClass('open'); + } + + function launchSearchFromQueryString() { + var q = getParameterByName('q'); + if (q && q.length > 0) { + // Update search input + $searchInput.val(q); + + // Launch search + launchSearch(q); + } + } + + function bindSearch() { + // Bind DOM + $searchInput = $('#book-search-input input'); + $bookSearchResults = $('#book-search-results'); + $searchList = $bookSearchResults.find('.search-results-list'); + $searchTitle = $bookSearchResults.find('.search-results-title'); + $searchResultsCount = $searchTitle.find('.search-results-count'); + $searchQuery = $searchTitle.find('.search-query'); + + // Launch query based on input content + function handleUpdate() { + var q = $searchInput.val(); + + if (q.length == 0) { + closeSearch(); + } + else { + launchSearch(q); + } + } + + // Detect true content change in search input + // Workaround for IE < 9 + var propertyChangeUnbound = false; + $searchInput.on('propertychange', function(e) { + if (e.originalEvent.propertyName == 'value') { + handleUpdate(); + } + }); + + // HTML5 (IE9 & others) + $searchInput.on('input', function(e) { + // Unbind propertychange event for IE9+ + if (!propertyChangeUnbound) { + $(this).unbind('propertychange'); + propertyChangeUnbound = true; + } + + handleUpdate(); + }); + + // Push to history on blur + $searchInput.on('blur', function(e) { + // Update history state + if (usePushState) { + var uri = updateQueryString('q', $(this).val()); + history.pushState({ path: uri }, null, uri); + } + }); + } + + gitbook.events.on('page.change', function() { + bindSearch(); + closeSearch(); + + // Launch search based on query parameter + if (gitbook.search.isInitialized()) { + launchSearchFromQueryString(); + } + }); + + gitbook.events.on('search.ready', function() { + bindSearch(); + + // Launch search from query param at start + launchSearchFromQueryString(); + }); + + function getParameterByName(name) { + var url = window.location.href; + name = name.replace(/[\[\]]/g, '\\$&'); + var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)', 'i'), + results = regex.exec(url); + if (!results) return null; + if (!results[2]) return ''; + return decodeURIComponent(results[2].replace(/\+/g, ' ')); + } + + function updateQueryString(key, value) { + value = encodeURIComponent(value); + + var url = window.location.href; + var re = new RegExp('([?&])' + key + '=.*?(&|#|$)(.*)', 'gi'), + hash; + + if (re.test(url)) { + if (typeof value !== 'undefined' && value !== null) + return url.replace(re, '$1' + key + '=' + value + '$2$3'); + else { + hash = url.split('#'); + url = hash[0].replace(re, '$1$3').replace(/(&|\?)$/, ''); + if (typeof hash[1] !== 'undefined' && hash[1] !== null) + url += '#' + hash[1]; + return url; + } + } + else { + if (typeof value !== 'undefined' && value !== null) { + var separator = url.indexOf('?') !== -1 ? '&' : '?'; + hash = url.split('#'); + url = hash[0] + separator + key + '=' + value; + if (typeof hash[1] !== 'undefined' && hash[1] !== null) + url += '#' + hash[1]; + return url; + } + else + return url; + } + } +}); diff --git a/docs/book/gitbook/gitbook-plugin-sharing/buttons.js b/docs/book/gitbook/gitbook-plugin-sharing/buttons.js new file mode 100644 index 000000000..709a4e4c0 --- /dev/null +++ b/docs/book/gitbook/gitbook-plugin-sharing/buttons.js @@ -0,0 +1,90 @@ +require(['gitbook', 'jquery'], function(gitbook, $) { + var SITES = { + 'facebook': { + 'label': 'Facebook', + 'icon': 'fa fa-facebook', + 'onClick': function(e) { + e.preventDefault(); + window.open('http://www.facebook.com/sharer/sharer.php?s=100&p[url]='+encodeURIComponent(location.href)); + } + }, + 'twitter': { + 'label': 'Twitter', + 'icon': 'fa fa-twitter', + 'onClick': function(e) { + e.preventDefault(); + window.open('http://twitter.com/home?status='+encodeURIComponent(document.title+' '+location.href)); + } + }, + 'google': { + 'label': 'Google+', + 'icon': 'fa fa-google-plus', + 'onClick': function(e) { + e.preventDefault(); + window.open('https://plus.google.com/share?url='+encodeURIComponent(location.href)); + } + }, + 'weibo': { + 'label': 'Weibo', + 'icon': 'fa fa-weibo', + 'onClick': function(e) { + e.preventDefault(); + window.open('http://service.weibo.com/share/share.php?content=utf-8&url='+encodeURIComponent(location.href)+'&title='+encodeURIComponent(document.title)); + } + }, + 'instapaper': { + 'label': 'Instapaper', + 'icon': 'fa fa-instapaper', + 'onClick': function(e) { + e.preventDefault(); + window.open('http://www.instapaper.com/text?u='+encodeURIComponent(location.href)); + } + }, + 'vk': { + 'label': 'VK', + 'icon': 'fa fa-vk', + 'onClick': function(e) { + e.preventDefault(); + window.open('http://vkontakte.ru/share.php?url='+encodeURIComponent(location.href)); + } + } + }; + + + + gitbook.events.bind('start', function(e, config) { + var opts = config.sharing; + + // Create dropdown menu + var menu = $.map(opts.all, function(id) { + var site = SITES[id]; + + return { + text: site.label, + onClick: site.onClick + }; + }); + + // Create main button with dropdown + if (menu.length > 0) { + gitbook.toolbar.createButton({ + icon: 'fa fa-share-alt', + label: 'Share', + position: 'right', + dropdown: [menu] + }); + } + + // Direct actions to share + $.each(SITES, function(sideId, site) { + if (!opts[sideId]) return; + + gitbook.toolbar.createButton({ + icon: site.icon, + label: site.text, + position: 'right', + onClick: site.onClick + }); + }); + }); +}); diff --git a/docs/book/gitbook/gitbook.js b/docs/book/gitbook/gitbook.js new file mode 100644 index 000000000..10000c790 --- /dev/null +++ b/docs/book/gitbook/gitbook.js @@ -0,0 +1,4 @@ +!function e(t,n,r){function o(s,a){if(!n[s]){if(!t[s]){var u="function"==typeof require&&require;if(!a&&u)return u(s,!0);if(i)return i(s,!0);var c=new Error("Cannot find module '"+s+"'");throw c.code="MODULE_NOT_FOUND",c}var l=n[s]={exports:{}};t[s][0].call(l.exports,function(e){var n=t[s][1][e];return o(n?n:e)},l,l.exports,e,t,n,r)}return n[s].exports}for(var i="function"==typeof require&&require,s=0;s0&&t-1 in e)}function o(e,t,n){return de.isFunction(t)?de.grep(e,function(e,r){return!!t.call(e,r,e)!==n}):t.nodeType?de.grep(e,function(e){return e===t!==n}):"string"!=typeof t?de.grep(e,function(e){return se.call(t,e)>-1!==n}):je.test(t)?de.filter(t,e,n):(t=de.filter(t,e),de.grep(e,function(e){return se.call(t,e)>-1!==n&&1===e.nodeType}))}function i(e,t){for(;(e=e[t])&&1!==e.nodeType;);return e}function s(e){var t={};return de.each(e.match(qe)||[],function(e,n){t[n]=!0}),t}function a(e){return e}function u(e){throw e}function c(e,t,n){var r;try{e&&de.isFunction(r=e.promise)?r.call(e).done(t).fail(n):e&&de.isFunction(r=e.then)?r.call(e,t,n):t.call(void 0,e)}catch(e){n.call(void 0,e)}}function l(){te.removeEventListener("DOMContentLoaded",l),e.removeEventListener("load",l),de.ready()}function f(){this.expando=de.expando+f.uid++}function p(e){return"true"===e||"false"!==e&&("null"===e?null:e===+e+""?+e:Ie.test(e)?JSON.parse(e):e)}function h(e,t,n){var r;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(Pe,"-$&").toLowerCase(),n=e.getAttribute(r),"string"==typeof n){try{n=p(n)}catch(e){}Re.set(e,t,n)}else n=void 0;return n}function d(e,t,n,r){var o,i=1,s=20,a=r?function(){return r.cur()}:function(){return de.css(e,t,"")},u=a(),c=n&&n[3]||(de.cssNumber[t]?"":"px"),l=(de.cssNumber[t]||"px"!==c&&+u)&&$e.exec(de.css(e,t));if(l&&l[3]!==c){c=c||l[3],n=n||[],l=+u||1;do i=i||".5",l/=i,de.style(e,t,l+c);while(i!==(i=a()/u)&&1!==i&&--s)}return n&&(l=+l||+u||0,o=n[1]?l+(n[1]+1)*n[2]:+n[2],r&&(r.unit=c,r.start=l,r.end=o)),o}function g(e){var t,n=e.ownerDocument,r=e.nodeName,o=Ue[r];return o?o:(t=n.body.appendChild(n.createElement(r)),o=de.css(t,"display"),t.parentNode.removeChild(t),"none"===o&&(o="block"),Ue[r]=o,o)}function m(e,t){for(var n,r,o=[],i=0,s=e.length;i-1)o&&o.push(i);else if(c=de.contains(i.ownerDocument,i),s=v(f.appendChild(i),"script"),c&&y(s),n)for(l=0;i=s[l++];)Ve.test(i.type||"")&&n.push(i);return f}function b(){return!0}function w(){return!1}function T(){try{return te.activeElement}catch(e){}}function C(e,t,n,r,o,i){var s,a;if("object"==typeof t){"string"!=typeof n&&(r=r||n,n=void 0);for(a in t)C(e,a,n,r,t[a],i);return e}if(null==r&&null==o?(o=n,r=n=void 0):null==o&&("string"==typeof n?(o=r,r=void 0):(o=r,r=n,n=void 0)),o===!1)o=w;else if(!o)return e;return 1===i&&(s=o,o=function(e){return de().off(e),s.apply(this,arguments)},o.guid=s.guid||(s.guid=de.guid++)),e.each(function(){de.event.add(this,t,o,r,n)})}function j(e,t){return de.nodeName(e,"table")&&de.nodeName(11!==t.nodeType?t:t.firstChild,"tr")?e.getElementsByTagName("tbody")[0]||e:e}function k(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function E(e){var t=rt.exec(e.type);return t?e.type=t[1]:e.removeAttribute("type"),e}function S(e,t){var n,r,o,i,s,a,u,c;if(1===t.nodeType){if(Fe.hasData(e)&&(i=Fe.access(e),s=Fe.set(t,i),c=i.events)){delete s.handle,s.events={};for(o in c)for(n=0,r=c[o].length;n1&&"string"==typeof d&&!pe.checkClone&&nt.test(d))return e.each(function(n){var i=e.eq(n);g&&(t[0]=d.call(this,n,i.html())),A(i,t,r,o)});if(p&&(i=x(t,e[0].ownerDocument,!1,e,o),s=i.firstChild,1===i.childNodes.length&&(i=s),s||o)){for(a=de.map(v(i,"script"),k),u=a.length;f=0&&nC.cacheLength&&delete e[t.shift()],e[n+" "]=r}var t=[];return e}function r(e){return e[$]=!0,e}function o(e){var t=L.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function i(e,t){for(var n=e.split("|"),r=n.length;r--;)C.attrHandle[n[r]]=t}function s(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)for(;n=n.nextSibling;)if(n===t)return-1;return e?1:-1}function a(e){return function(t){var n=t.nodeName.toLowerCase();return"input"===n&&t.type===e}}function u(e){return function(t){var n=t.nodeName.toLowerCase();return("input"===n||"button"===n)&&t.type===e}}function c(e){return function(t){return"form"in t?t.parentNode&&t.disabled===!1?"label"in t?"label"in t.parentNode?t.parentNode.disabled===e:t.disabled===e:t.isDisabled===e||t.isDisabled!==!e&&je(t)===e:t.disabled===e:"label"in t&&t.disabled===e}}function l(e){return r(function(t){return t=+t,r(function(n,r){for(var o,i=e([],n.length,t),s=i.length;s--;)n[o=i[s]]&&(n[o]=!(r[o]=n[o]))})})}function f(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}function p(){}function h(e){for(var t=0,n=e.length,r="";t1?function(t,n,r){for(var o=e.length;o--;)if(!e[o](t,n,r))return!1;return!0}:e[0]}function m(e,n,r){for(var o=0,i=n.length;o-1&&(r[c]=!(s[c]=f))}}else x=v(x===s?x.splice(d,x.length):x),i?i(null,s,x,u):K.apply(s,x)})}function x(e){for(var t,n,r,o=e.length,i=C.relative[e[0].type],s=i||C.relative[" "],a=i?1:0,u=d(function(e){return e===t},s,!0),c=d(function(e){return ee(t,e)>-1},s,!0),l=[function(e,n,r){var o=!i&&(r||n!==A)||((t=n).nodeType?u(e,n,r):c(e,n,r));return t=null,o}];a1&&g(l),a>1&&h(e.slice(0,a-1).concat({value:" "===e[a-2].type?"*":""})).replace(ae,"$1"),n,a0,i=e.length>0,s=function(r,s,a,u,c){var l,f,p,h=0,d="0",g=r&&[],m=[],y=A,x=r||i&&C.find.TAG("*",c),b=B+=null==y?1:Math.random()||.1,w=x.length;for(c&&(A=s===L||s||c);d!==w&&null!=(l=x[d]);d++){if(i&&l){for(f=0,s||l.ownerDocument===L||(O(l),a=!F);p=e[f++];)if(p(l,s||L,a)){u.push(l);break}c&&(B=b)}o&&((l=!p&&l)&&h--,r&&g.push(l))}if(h+=d,o&&d!==h){for(f=0;p=n[f++];)p(g,m,s,a);if(r){if(h>0)for(;d--;)g[d]||m[d]||(m[d]=Q.call(u));m=v(m)}K.apply(u,m),c&&!r&&m.length>0&&h+n.length>1&&t.uniqueSort(u)}return c&&(B=b,A=y),g};return o?r(s):s}var w,T,C,j,k,E,S,N,A,q,D,O,L,H,F,R,I,P,M,$="sizzle"+1*new Date,W=e.document,B=0,_=0,U=n(),z=n(),X=n(),V=function(e,t){return e===t&&(D=!0),0},G={}.hasOwnProperty,Y=[],Q=Y.pop,J=Y.push,K=Y.push,Z=Y.slice,ee=function(e,t){for(var n=0,r=e.length;n+~]|"+ne+")"+ne+"*"),le=new RegExp("="+ne+"*([^\\]'\"]*?)"+ne+"*\\]","g"),fe=new RegExp(ie),pe=new RegExp("^"+re+"$"),he={ID:new RegExp("^#("+re+")"),CLASS:new RegExp("^\\.("+re+")"),TAG:new RegExp("^("+re+"|[*])"),ATTR:new RegExp("^"+oe),PSEUDO:new RegExp("^"+ie),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+ne+"*(even|odd|(([+-]|)(\\d*)n|)"+ne+"*(?:([+-]|)"+ne+"*(\\d+)|))"+ne+"*\\)|)","i"),bool:new RegExp("^(?:"+te+")$","i"),needsContext:new RegExp("^"+ne+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+ne+"*((?:-\\d)?\\d*)"+ne+"*\\)|)(?=[^-]|$)","i")},de=/^(?:input|select|textarea|button)$/i,ge=/^h\d$/i,me=/^[^{]+\{\s*\[native \w/,ve=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ye=/[+~]/,xe=new RegExp("\\\\([\\da-f]{1,6}"+ne+"?|("+ne+")|.)","ig"),be=function(e,t,n){var r="0x"+t-65536;return r!==r||n?t:r<0?String.fromCharCode(r+65536):String.fromCharCode(r>>10|55296,1023&r|56320)},we=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,Te=function(e,t){return t?"\0"===e?"�":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},Ce=function(){O()},je=d(function(e){return e.disabled===!0&&("form"in e||"label"in e)},{dir:"parentNode",next:"legend"});try{K.apply(Y=Z.call(W.childNodes),W.childNodes),Y[W.childNodes.length].nodeType}catch(e){K={apply:Y.length?function(e,t){J.apply(e,Z.call(t))}:function(e,t){for(var n=e.length,r=0;e[n++]=t[r++];);e.length=n-1}}}T=t.support={},k=t.isXML=function(e){var t=e&&(e.ownerDocument||e).documentElement;return!!t&&"HTML"!==t.nodeName},O=t.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:W;return r!==L&&9===r.nodeType&&r.documentElement?(L=r,H=L.documentElement,F=!k(L),W!==L&&(n=L.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",Ce,!1):n.attachEvent&&n.attachEvent("onunload",Ce)),T.attributes=o(function(e){return e.className="i",!e.getAttribute("className")}),T.getElementsByTagName=o(function(e){return e.appendChild(L.createComment("")),!e.getElementsByTagName("*").length}),T.getElementsByClassName=me.test(L.getElementsByClassName),T.getById=o(function(e){return H.appendChild(e).id=$,!L.getElementsByName||!L.getElementsByName($).length}),T.getById?(C.filter.ID=function(e){var t=e.replace(xe,be);return function(e){return e.getAttribute("id")===t}},C.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&F){var n=t.getElementById(e);return n?[n]:[]}}):(C.filter.ID=function(e){var t=e.replace(xe,be);return function(e){var n="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return n&&n.value===t}},C.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&F){var n,r,o,i=t.getElementById(e);if(i){if(n=i.getAttributeNode("id"),n&&n.value===e)return[i];for(o=t.getElementsByName(e),r=0;i=o[r++];)if(n=i.getAttributeNode("id"),n&&n.value===e)return[i]}return[]}}),C.find.TAG=T.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):T.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],o=0,i=t.getElementsByTagName(e);if("*"===e){for(;n=i[o++];)1===n.nodeType&&r.push(n);return r}return i},C.find.CLASS=T.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&F)return t.getElementsByClassName(e)},I=[],R=[],(T.qsa=me.test(L.querySelectorAll))&&(o(function(e){H.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&R.push("[*^$]="+ne+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||R.push("\\["+ne+"*(?:value|"+te+")"),e.querySelectorAll("[id~="+$+"-]").length||R.push("~="),e.querySelectorAll(":checked").length||R.push(":checked"),e.querySelectorAll("a#"+$+"+*").length||R.push(".#.+[+~]")}),o(function(e){e.innerHTML="";var t=L.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&R.push("name"+ne+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&R.push(":enabled",":disabled"),H.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&R.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),R.push(",.*:")})),(T.matchesSelector=me.test(P=H.matches||H.webkitMatchesSelector||H.mozMatchesSelector||H.oMatchesSelector||H.msMatchesSelector))&&o(function(e){T.disconnectedMatch=P.call(e,"*"),P.call(e,"[s!='']:x"),I.push("!=",ie)}),R=R.length&&new RegExp(R.join("|")),I=I.length&&new RegExp(I.join("|")),t=me.test(H.compareDocumentPosition),M=t||me.test(H.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)for(;t=t.parentNode;)if(t===e)return!0;return!1},V=t?function(e,t){if(e===t)return D=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n?n:(n=(e.ownerDocument||e)===(t.ownerDocument||t)?e.compareDocumentPosition(t):1,1&n||!T.sortDetached&&t.compareDocumentPosition(e)===n?e===L||e.ownerDocument===W&&M(W,e)?-1:t===L||t.ownerDocument===W&&M(W,t)?1:q?ee(q,e)-ee(q,t):0:4&n?-1:1)}:function(e,t){if(e===t)return D=!0,0;var n,r=0,o=e.parentNode,i=t.parentNode,a=[e],u=[t];if(!o||!i)return e===L?-1:t===L?1:o?-1:i?1:q?ee(q,e)-ee(q,t):0;if(o===i)return s(e,t);for(n=e;n=n.parentNode;)a.unshift(n);for(n=t;n=n.parentNode;)u.unshift(n);for(;a[r]===u[r];)r++;return r?s(a[r],u[r]):a[r]===W?-1:u[r]===W?1:0},L):L},t.matches=function(e,n){return t(e,null,null,n)},t.matchesSelector=function(e,n){if((e.ownerDocument||e)!==L&&O(e),n=n.replace(le,"='$1']"),T.matchesSelector&&F&&!X[n+" "]&&(!I||!I.test(n))&&(!R||!R.test(n)))try{var r=P.call(e,n);if(r||T.disconnectedMatch||e.document&&11!==e.document.nodeType)return r}catch(e){}return t(n,L,null,[e]).length>0},t.contains=function(e,t){return(e.ownerDocument||e)!==L&&O(e),M(e,t)},t.attr=function(e,t){(e.ownerDocument||e)!==L&&O(e);var n=C.attrHandle[t.toLowerCase()],r=n&&G.call(C.attrHandle,t.toLowerCase())?n(e,t,!F):void 0;return void 0!==r?r:T.attributes||!F?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},t.escape=function(e){return(e+"").replace(we,Te)},t.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},t.uniqueSort=function(e){var t,n=[],r=0,o=0;if(D=!T.detectDuplicates,q=!T.sortStable&&e.slice(0),e.sort(V),D){for(;t=e[o++];)t===e[o]&&(r=n.push(o));for(;r--;)e.splice(n[r],1)}return q=null,e},j=t.getText=function(e){var t,n="",r=0,o=e.nodeType;if(o){if(1===o||9===o||11===o){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=j(e)}else if(3===o||4===o)return e.nodeValue}else for(;t=e[r++];)n+=j(t);return n},C=t.selectors={cacheLength:50,createPseudo:r,match:he,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(xe,be),e[3]=(e[3]||e[4]||e[5]||"").replace(xe,be),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||t.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&t.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return he.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&fe.test(n)&&(t=E(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(xe,be).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=U[e+" "];return t||(t=new RegExp("(^|"+ne+")"+e+"("+ne+"|$)"))&&U(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(e,n,r){return function(o){var i=t.attr(o,e);return null==i?"!="===n:!n||(i+="","="===n?i===r:"!="===n?i!==r:"^="===n?r&&0===i.indexOf(r):"*="===n?r&&i.indexOf(r)>-1:"$="===n?r&&i.slice(-r.length)===r:"~="===n?(" "+i.replace(se," ")+" ").indexOf(r)>-1:"|="===n&&(i===r||i.slice(0,r.length+1)===r+"-"))}},CHILD:function(e,t,n,r,o){var i="nth"!==e.slice(0,3),s="last"!==e.slice(-4),a="of-type"===t;return 1===r&&0===o?function(e){return!!e.parentNode}:function(t,n,u){var c,l,f,p,h,d,g=i!==s?"nextSibling":"previousSibling",m=t.parentNode,v=a&&t.nodeName.toLowerCase(),y=!u&&!a,x=!1;if(m){if(i){for(;g;){for(p=t;p=p[g];)if(a?p.nodeName.toLowerCase()===v:1===p.nodeType)return!1;d=g="only"===e&&!d&&"nextSibling"}return!0}if(d=[s?m.firstChild:m.lastChild],s&&y){for(p=m,f=p[$]||(p[$]={}),l=f[p.uniqueID]||(f[p.uniqueID]={}),c=l[e]||[],h=c[0]===B&&c[1],x=h&&c[2],p=h&&m.childNodes[h];p=++h&&p&&p[g]||(x=h=0)||d.pop();)if(1===p.nodeType&&++x&&p===t){l[e]=[B,h,x];break}}else if(y&&(p=t,f=p[$]||(p[$]={}),l=f[p.uniqueID]||(f[p.uniqueID]={}),c=l[e]||[],h=c[0]===B&&c[1],x=h),x===!1)for(;(p=++h&&p&&p[g]||(x=h=0)||d.pop())&&((a?p.nodeName.toLowerCase()!==v:1!==p.nodeType)||!++x||(y&&(f=p[$]||(p[$]={}),l=f[p.uniqueID]||(f[p.uniqueID]={}),l[e]=[B,x]),p!==t)););return x-=o,x===r||x%r===0&&x/r>=0}}},PSEUDO:function(e,n){var o,i=C.pseudos[e]||C.setFilters[e.toLowerCase()]||t.error("unsupported pseudo: "+e);return i[$]?i(n):i.length>1?(o=[e,e,"",n],C.setFilters.hasOwnProperty(e.toLowerCase())?r(function(e,t){for(var r,o=i(e,n),s=o.length;s--;)r=ee(e,o[s]),e[r]=!(t[r]=o[s])}):function(e){return i(e,0,o)}):i}},pseudos:{not:r(function(e){var t=[],n=[],o=S(e.replace(ae,"$1"));return o[$]?r(function(e,t,n,r){for(var i,s=o(e,null,r,[]),a=e.length;a--;)(i=s[a])&&(e[a]=!(t[a]=i))}):function(e,r,i){return t[0]=e,o(t,null,i,n),t[0]=null,!n.pop()}}),has:r(function(e){return function(n){ +return t(e,n).length>0}}),contains:r(function(e){return e=e.replace(xe,be),function(t){return(t.textContent||t.innerText||j(t)).indexOf(e)>-1}}),lang:r(function(e){return pe.test(e||"")||t.error("unsupported lang: "+e),e=e.replace(xe,be).toLowerCase(),function(t){var n;do if(n=F?t.lang:t.getAttribute("xml:lang")||t.getAttribute("lang"))return n=n.toLowerCase(),n===e||0===n.indexOf(e+"-");while((t=t.parentNode)&&1===t.nodeType);return!1}}),target:function(t){var n=e.location&&e.location.hash;return n&&n.slice(1)===t.id},root:function(e){return e===H},focus:function(e){return e===L.activeElement&&(!L.hasFocus||L.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:c(!1),disabled:c(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,e.selected===!0},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!C.pseudos.empty(e)},header:function(e){return ge.test(e.nodeName)},input:function(e){return de.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:l(function(){return[0]}),last:l(function(e,t){return[t-1]}),eq:l(function(e,t,n){return[n<0?n+t:n]}),even:l(function(e,t){for(var n=0;n=0;)e.push(r);return e}),gt:l(function(e,t,n){for(var r=n<0?n+t:n;++r2&&"ID"===(s=i[0]).type&&9===t.nodeType&&F&&C.relative[i[1].type]){if(t=(C.find.ID(s.matches[0].replace(xe,be),t)||[])[0],!t)return n;c&&(t=t.parentNode),e=e.slice(i.shift().value.length)}for(o=he.needsContext.test(e)?0:i.length;o--&&(s=i[o],!C.relative[a=s.type]);)if((u=C.find[a])&&(r=u(s.matches[0].replace(xe,be),ye.test(i[0].type)&&f(t.parentNode)||t))){if(i.splice(o,1),e=r.length&&h(i),!e)return K.apply(n,r),n;break}}return(c||S(e,l))(r,t,!F,n,!t||ye.test(e)&&f(t.parentNode)||t),n},T.sortStable=$.split("").sort(V).join("")===$,T.detectDuplicates=!!D,O(),T.sortDetached=o(function(e){return 1&e.compareDocumentPosition(L.createElement("fieldset"))}),o(function(e){return e.innerHTML="","#"===e.firstChild.getAttribute("href")})||i("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),T.attributes&&o(function(e){return e.innerHTML="",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||i("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),o(function(e){return null==e.getAttribute("disabled")})||i(te,function(e,t,n){var r;if(!n)return e[t]===!0?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),t}(e);de.find=xe,de.expr=xe.selectors,de.expr[":"]=de.expr.pseudos,de.uniqueSort=de.unique=xe.uniqueSort,de.text=xe.getText,de.isXMLDoc=xe.isXML,de.contains=xe.contains,de.escapeSelector=xe.escape;var be=function(e,t,n){for(var r=[],o=void 0!==n;(e=e[t])&&9!==e.nodeType;)if(1===e.nodeType){if(o&&de(e).is(n))break;r.push(e)}return r},we=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},Te=de.expr.match.needsContext,Ce=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i,je=/^.[^:#\[\.,]*$/;de.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?de.find.matchesSelector(r,e)?[r]:[]:de.find.matches(e,de.grep(t,function(e){return 1===e.nodeType}))},de.fn.extend({find:function(e){var t,n,r=this.length,o=this;if("string"!=typeof e)return this.pushStack(de(e).filter(function(){for(t=0;t1?de.uniqueSort(n):n},filter:function(e){return this.pushStack(o(this,e||[],!1))},not:function(e){return this.pushStack(o(this,e||[],!0))},is:function(e){return!!o(this,"string"==typeof e&&Te.test(e)?de(e):e||[],!1).length}});var ke,Ee=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,Se=de.fn.init=function(e,t,n){var r,o;if(!e)return this;if(n=n||ke,"string"==typeof e){if(r="<"===e[0]&&">"===e[e.length-1]&&e.length>=3?[null,e,null]:Ee.exec(e),!r||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof de?t[0]:t,de.merge(this,de.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:te,!0)),Ce.test(r[1])&&de.isPlainObject(t))for(r in t)de.isFunction(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return o=te.getElementById(r[2]),o&&(this[0]=o,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):de.isFunction(e)?void 0!==n.ready?n.ready(e):e(de):de.makeArray(e,this)};Se.prototype=de.fn,ke=de(te);var Ne=/^(?:parents|prev(?:Until|All))/,Ae={children:!0,contents:!0,next:!0,prev:!0};de.fn.extend({has:function(e){var t=de(e,this),n=t.length;return this.filter(function(){for(var e=0;e-1:1===n.nodeType&&de.find.matchesSelector(n,e))){i.push(n);break}return this.pushStack(i.length>1?de.uniqueSort(i):i)},index:function(e){return e?"string"==typeof e?se.call(de(e),this[0]):se.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(de.uniqueSort(de.merge(this.get(),de(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),de.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return be(e,"parentNode")},parentsUntil:function(e,t,n){return be(e,"parentNode",n)},next:function(e){return i(e,"nextSibling")},prev:function(e){return i(e,"previousSibling")},nextAll:function(e){return be(e,"nextSibling")},prevAll:function(e){return be(e,"previousSibling")},nextUntil:function(e,t,n){return be(e,"nextSibling",n)},prevUntil:function(e,t,n){return be(e,"previousSibling",n)},siblings:function(e){return we((e.parentNode||{}).firstChild,e)},children:function(e){return we(e.firstChild)},contents:function(e){return e.contentDocument||de.merge([],e.childNodes)}},function(e,t){de.fn[e]=function(n,r){var o=de.map(this,t,n);return"Until"!==e.slice(-5)&&(r=n),r&&"string"==typeof r&&(o=de.filter(r,o)),this.length>1&&(Ae[e]||de.uniqueSort(o),Ne.test(e)&&o.reverse()),this.pushStack(o)}});var qe=/[^\x20\t\r\n\f]+/g;de.Callbacks=function(e){e="string"==typeof e?s(e):de.extend({},e);var t,n,r,o,i=[],a=[],u=-1,c=function(){for(o=e.once,r=t=!0;a.length;u=-1)for(n=a.shift();++u-1;)i.splice(n,1),n<=u&&u--}),this},has:function(e){return e?de.inArray(e,i)>-1:i.length>0},empty:function(){return i&&(i=[]),this},disable:function(){return o=a=[],i=n="",this},disabled:function(){return!i},lock:function(){return o=a=[],n||t||(i=n=""),this},locked:function(){return!!o},fireWith:function(e,n){return o||(n=n||[],n=[e,n.slice?n.slice():n],a.push(n),t||c()),this},fire:function(){return l.fireWith(this,arguments),this},fired:function(){return!!r}};return l},de.extend({Deferred:function(t){var n=[["notify","progress",de.Callbacks("memory"),de.Callbacks("memory"),2],["resolve","done",de.Callbacks("once memory"),de.Callbacks("once memory"),0,"resolved"],["reject","fail",de.Callbacks("once memory"),de.Callbacks("once memory"),1,"rejected"]],r="pending",o={state:function(){return r},always:function(){return i.done(arguments).fail(arguments),this},catch:function(e){return o.then(null,e)},pipe:function(){var e=arguments;return de.Deferred(function(t){de.each(n,function(n,r){var o=de.isFunction(e[r[4]])&&e[r[4]];i[r[1]](function(){var e=o&&o.apply(this,arguments);e&&de.isFunction(e.promise)?e.promise().progress(t.notify).done(t.resolve).fail(t.reject):t[r[0]+"With"](this,o?[e]:arguments)})}),e=null}).promise()},then:function(t,r,o){function i(t,n,r,o){return function(){var c=this,l=arguments,f=function(){var e,f;if(!(t=s&&(r!==u&&(c=void 0,l=[e]),n.rejectWith(c,l))}};t?p():(de.Deferred.getStackHook&&(p.stackTrace=de.Deferred.getStackHook()),e.setTimeout(p))}}var s=0;return de.Deferred(function(e){n[0][3].add(i(0,e,de.isFunction(o)?o:a,e.notifyWith)),n[1][3].add(i(0,e,de.isFunction(t)?t:a)),n[2][3].add(i(0,e,de.isFunction(r)?r:u))}).promise()},promise:function(e){return null!=e?de.extend(e,o):o}},i={};return de.each(n,function(e,t){var s=t[2],a=t[5];o[t[1]]=s.add,a&&s.add(function(){r=a},n[3-e][2].disable,n[0][2].lock),s.add(t[3].fire),i[t[0]]=function(){return i[t[0]+"With"](this===i?void 0:this,arguments),this},i[t[0]+"With"]=s.fireWith}),o.promise(i),t&&t.call(i,i),i},when:function(e){var t=arguments.length,n=t,r=Array(n),o=re.call(arguments),i=de.Deferred(),s=function(e){return function(n){r[e]=this,o[e]=arguments.length>1?re.call(arguments):n,--t||i.resolveWith(r,o)}};if(t<=1&&(c(e,i.done(s(n)).resolve,i.reject),"pending"===i.state()||de.isFunction(o[n]&&o[n].then)))return i.then();for(;n--;)c(o[n],s(n),i.reject);return i.promise()}});var De=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;de.Deferred.exceptionHook=function(t,n){e.console&&e.console.warn&&t&&De.test(t.name)&&e.console.warn("jQuery.Deferred exception: "+t.message,t.stack,n)},de.readyException=function(t){e.setTimeout(function(){throw t})};var Oe=de.Deferred();de.fn.ready=function(e){return Oe.then(e).catch(function(e){de.readyException(e)}),this},de.extend({isReady:!1,readyWait:1,holdReady:function(e){e?de.readyWait++:de.ready(!0)},ready:function(e){(e===!0?--de.readyWait:de.isReady)||(de.isReady=!0,e!==!0&&--de.readyWait>0||Oe.resolveWith(te,[de]))}}),de.ready.then=Oe.then,"complete"===te.readyState||"loading"!==te.readyState&&!te.documentElement.doScroll?e.setTimeout(de.ready):(te.addEventListener("DOMContentLoaded",l),e.addEventListener("load",l));var Le=function(e,t,n,r,o,i,s){var a=0,u=e.length,c=null==n;if("object"===de.type(n)){o=!0;for(a in n)Le(e,t,a,n[a],!0,i,s)}else if(void 0!==r&&(o=!0,de.isFunction(r)||(s=!0),c&&(s?(t.call(e,r),t=null):(c=t,t=function(e,t,n){return c.call(de(e),n)})),t))for(;a1,null,!0)},removeData:function(e){return this.each(function(){Re.remove(this,e)})}}),de.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Fe.get(e,t),n&&(!r||de.isArray(n)?r=Fe.access(e,t,de.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=de.queue(e,t),r=n.length,o=n.shift(),i=de._queueHooks(e,t),s=function(){de.dequeue(e,t)};"inprogress"===o&&(o=n.shift(),r--),o&&("fx"===t&&n.unshift("inprogress"),delete i.stop,o.call(e,s,i)),!r&&i&&i.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Fe.get(e,n)||Fe.access(e,n,{empty:de.Callbacks("once memory").add(function(){Fe.remove(e,[t+"queue",n])})})}}),de.fn.extend({queue:function(e,t){var n=2;return"string"!=typeof e&&(t=e,e="fx",n--),arguments.length\x20\t\r\n\f]+)/i,Ve=/^$|\/(?:java|ecma)script/i,Ge={option:[1,""],thead:[1,"","
                "],col:[2,"","
                "],tr:[2,"","
                "],td:[3,"","
                "],_default:[0,"",""]};Ge.optgroup=Ge.option,Ge.tbody=Ge.tfoot=Ge.colgroup=Ge.caption=Ge.thead,Ge.th=Ge.td;var Ye=/<|&#?\w+;/;!function(){var e=te.createDocumentFragment(),t=e.appendChild(te.createElement("div")),n=te.createElement("input");n.setAttribute("type","radio"),n.setAttribute("checked","checked"),n.setAttribute("name","t"),t.appendChild(n),pe.checkClone=t.cloneNode(!0).cloneNode(!0).lastChild.checked,t.innerHTML="",pe.noCloneChecked=!!t.cloneNode(!0).lastChild.defaultValue}();var Qe=te.documentElement,Je=/^key/,Ke=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Ze=/^([^.]*)(?:\.(.+)|)/;de.event={global:{},add:function(e,t,n,r,o){var i,s,a,u,c,l,f,p,h,d,g,m=Fe.get(e);if(m)for(n.handler&&(i=n,n=i.handler,o=i.selector),o&&de.find.matchesSelector(Qe,o),n.guid||(n.guid=de.guid++),(u=m.events)||(u=m.events={}),(s=m.handle)||(s=m.handle=function(t){return"undefined"!=typeof de&&de.event.triggered!==t.type?de.event.dispatch.apply(e,arguments):void 0}),t=(t||"").match(qe)||[""],c=t.length;c--;)a=Ze.exec(t[c])||[],h=g=a[1],d=(a[2]||"").split(".").sort(),h&&(f=de.event.special[h]||{},h=(o?f.delegateType:f.bindType)||h,f=de.event.special[h]||{},l=de.extend({type:h,origType:g,data:r,handler:n,guid:n.guid,selector:o,needsContext:o&&de.expr.match.needsContext.test(o),namespace:d.join(".")},i),(p=u[h])||(p=u[h]=[],p.delegateCount=0,f.setup&&f.setup.call(e,r,d,s)!==!1||e.addEventListener&&e.addEventListener(h,s)),f.add&&(f.add.call(e,l),l.handler.guid||(l.handler.guid=n.guid)),o?p.splice(p.delegateCount++,0,l):p.push(l),de.event.global[h]=!0)},remove:function(e,t,n,r,o){var i,s,a,u,c,l,f,p,h,d,g,m=Fe.hasData(e)&&Fe.get(e);if(m&&(u=m.events)){for(t=(t||"").match(qe)||[""],c=t.length;c--;)if(a=Ze.exec(t[c])||[],h=g=a[1],d=(a[2]||"").split(".").sort(),h){for(f=de.event.special[h]||{},h=(r?f.delegateType:f.bindType)||h,p=u[h]||[],a=a[2]&&new RegExp("(^|\\.)"+d.join("\\.(?:.*\\.|)")+"(\\.|$)"),s=i=p.length;i--;)l=p[i],!o&&g!==l.origType||n&&n.guid!==l.guid||a&&!a.test(l.namespace)||r&&r!==l.selector&&("**"!==r||!l.selector)||(p.splice(i,1),l.selector&&p.delegateCount--,f.remove&&f.remove.call(e,l));s&&!p.length&&(f.teardown&&f.teardown.call(e,d,m.handle)!==!1||de.removeEvent(e,h,m.handle),delete u[h])}else for(h in u)de.event.remove(e,h+t[c],n,r,!0);de.isEmptyObject(u)&&Fe.remove(e,"handle events")}},dispatch:function(e){var t,n,r,o,i,s,a=de.event.fix(e),u=new Array(arguments.length),c=(Fe.get(this,"events")||{})[a.type]||[],l=de.event.special[a.type]||{};for(u[0]=a,t=1;t=1))for(;c!==this;c=c.parentNode||this)if(1===c.nodeType&&("click"!==e.type||c.disabled!==!0)){for(i=[],s={},n=0;n-1:de.find(o,this,null,[c]).length),s[o]&&i.push(r);i.length&&a.push({elem:c,handlers:i})}return c=this,u\x20\t\r\n\f]*)[^>]*)\/>/gi,tt=/\s*$/g;de.extend({htmlPrefilter:function(e){return e.replace(et,"<$1>")},clone:function(e,t,n){var r,o,i,s,a=e.cloneNode(!0),u=de.contains(e.ownerDocument,e);if(!(pe.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||de.isXMLDoc(e)))for(s=v(a),i=v(e),r=0,o=i.length;r0&&y(s,!u&&v(e,"script")),a},cleanData:function(e){for(var t,n,r,o=de.event.special,i=0;void 0!==(n=e[i]);i++)if(He(n)){if(t=n[Fe.expando]){if(t.events)for(r in t.events)o[r]?de.event.remove(n,r):de.removeEvent(n,r,t.handle);n[Fe.expando]=void 0}n[Re.expando]&&(n[Re.expando]=void 0)}}}),de.fn.extend({detach:function(e){return q(this,e,!0)},remove:function(e){return q(this,e)},text:function(e){return Le(this,function(e){return void 0===e?de.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return A(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=j(this,e);t.appendChild(e)}})},prepend:function(){return A(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=j(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return A(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return A(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(de.cleanData(v(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return de.clone(this,e,t)})},html:function(e){return Le(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!tt.test(e)&&!Ge[(Xe.exec(e)||["",""])[1].toLowerCase()]){e=de.htmlPrefilter(e);try{for(;n1)}}),de.Tween=I,I.prototype={constructor:I,init:function(e,t,n,r,o,i){this.elem=e,this.prop=n,this.easing=o||de.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=i||(de.cssNumber[n]?"":"px")},cur:function(){var e=I.propHooks[this.prop];return e&&e.get?e.get(this):I.propHooks._default.get(this)},run:function(e){var t,n=I.propHooks[this.prop];return this.options.duration?this.pos=t=de.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):I.propHooks._default.set(this),this}},I.prototype.init.prototype=I.prototype,I.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=de.css(e.elem,e.prop,""),t&&"auto"!==t?t:0)},set:function(e){de.fx.step[e.prop]?de.fx.step[e.prop](e):1!==e.elem.nodeType||null==e.elem.style[de.cssProps[e.prop]]&&!de.cssHooks[e.prop]?e.elem[e.prop]=e.now:de.style(e.elem,e.prop,e.now+e.unit)}}},I.propHooks.scrollTop=I.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},de.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},de.fx=I.prototype.init,de.fx.step={};var ht,dt,gt=/^(?:toggle|show|hide)$/,mt=/queueHooks$/;de.Animation=de.extend(U,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return d(n.elem,e,$e.exec(t),n),n}]},tweener:function(e,t){de.isFunction(e)?(t=e,e=["*"]):e=e.match(qe);for(var n,r=0,o=e.length;r1)},removeAttr:function(e){return this.each(function(){de.removeAttr(this,e)})}}),de.extend({attr:function(e,t,n){var r,o,i=e.nodeType;if(3!==i&&8!==i&&2!==i)return"undefined"==typeof e.getAttribute?de.prop(e,t,n):(1===i&&de.isXMLDoc(e)||(o=de.attrHooks[t.toLowerCase()]||(de.expr.match.bool.test(t)?vt:void 0)),void 0!==n?null===n?void de.removeAttr(e,t):o&&"set"in o&&void 0!==(r=o.set(e,n,t))?r:(e.setAttribute(t,n+""),n):o&&"get"in o&&null!==(r=o.get(e,t))?r:(r=de.find.attr(e,t),null==r?void 0:r))},attrHooks:{type:{set:function(e,t){if(!pe.radioValue&&"radio"===t&&de.nodeName(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,o=t&&t.match(qe);if(o&&1===e.nodeType)for(;n=o[r++];)e.removeAttribute(n)}}),vt={set:function(e,t,n){return t===!1?de.removeAttr(e,n):e.setAttribute(n,n),n}},de.each(de.expr.match.bool.source.match(/\w+/g),function(e,t){var n=yt[t]||de.find.attr;yt[t]=function(e,t,r){var o,i,s=t.toLowerCase();return r||(i=yt[s],yt[s]=o,o=null!=n(e,t,r)?s:null,yt[s]=i),o}});var xt=/^(?:input|select|textarea|button)$/i,bt=/^(?:a|area)$/i;de.fn.extend({prop:function(e,t){return Le(this,de.prop,e,t,arguments.length>1)},removeProp:function(e){return this.each(function(){delete this[de.propFix[e]||e]})}}),de.extend({prop:function(e,t,n){var r,o,i=e.nodeType;if(3!==i&&8!==i&&2!==i)return 1===i&&de.isXMLDoc(e)||(t=de.propFix[t]||t,o=de.propHooks[t]),void 0!==n?o&&"set"in o&&void 0!==(r=o.set(e,n,t))?r:e[t]=n:o&&"get"in o&&null!==(r=o.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=de.find.attr(e,"tabindex");return t?parseInt(t,10):xt.test(e.nodeName)||bt.test(e.nodeName)&&e.href?0:-1}}},propFix:{for:"htmlFor",class:"className"}}),pe.optSelected||(de.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),de.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){de.propFix[this.toLowerCase()]=this}),de.fn.extend({addClass:function(e){var t,n,r,o,i,s,a,u=0;if(de.isFunction(e))return this.each(function(t){de(this).addClass(e.call(this,t,X(this)))});if("string"==typeof e&&e)for(t=e.match(qe)||[];n=this[u++];)if(o=X(n),r=1===n.nodeType&&" "+z(o)+" "){for(s=0;i=t[s++];)r.indexOf(" "+i+" ")<0&&(r+=i+" ");a=z(r),o!==a&&n.setAttribute("class",a)}return this},removeClass:function(e){var t,n,r,o,i,s,a,u=0;if(de.isFunction(e))return this.each(function(t){de(this).removeClass(e.call(this,t,X(this)))});if(!arguments.length)return this.attr("class","");if("string"==typeof e&&e)for(t=e.match(qe)||[];n=this[u++];)if(o=X(n),r=1===n.nodeType&&" "+z(o)+" "){for(s=0;i=t[s++];)for(;r.indexOf(" "+i+" ")>-1;)r=r.replace(" "+i+" "," ");a=z(r),o!==a&&n.setAttribute("class",a)}return this},toggleClass:function(e,t){var n=typeof e;return"boolean"==typeof t&&"string"===n?t?this.addClass(e):this.removeClass(e):de.isFunction(e)?this.each(function(n){de(this).toggleClass(e.call(this,n,X(this),t),t)}):this.each(function(){var t,r,o,i;if("string"===n)for(r=0,o=de(this),i=e.match(qe)||[];t=i[r++];)o.hasClass(t)?o.removeClass(t):o.addClass(t);else void 0!==e&&"boolean"!==n||(t=X(this),t&&Fe.set(this,"__className__",t),this.setAttribute&&this.setAttribute("class",t||e===!1?"":Fe.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;for(t=" "+e+" ";n=this[r++];)if(1===n.nodeType&&(" "+z(X(n))+" ").indexOf(t)>-1)return!0;return!1}});var wt=/\r/g;de.fn.extend({val:function(e){var t,n,r,o=this[0];{if(arguments.length)return r=de.isFunction(e),this.each(function(n){var o;1===this.nodeType&&(o=r?e.call(this,n,de(this).val()):e,null==o?o="":"number"==typeof o?o+="":de.isArray(o)&&(o=de.map(o,function(e){return null==e?"":e+""})),t=de.valHooks[this.type]||de.valHooks[this.nodeName.toLowerCase()],t&&"set"in t&&void 0!==t.set(this,o,"value")||(this.value=o))});if(o)return t=de.valHooks[o.type]||de.valHooks[o.nodeName.toLowerCase()],t&&"get"in t&&void 0!==(n=t.get(o,"value"))?n:(n=o.value,"string"==typeof n?n.replace(wt,""):null==n?"":n)}}}),de.extend({valHooks:{option:{get:function(e){var t=de.find.attr(e,"value");return null!=t?t:z(de.text(e))}},select:{get:function(e){var t,n,r,o=e.options,i=e.selectedIndex,s="select-one"===e.type,a=s?null:[],u=s?i+1:o.length;for(r=i<0?u:s?i:0;r-1)&&(n=!0);return n||(e.selectedIndex=-1),i}}}}),de.each(["radio","checkbox"],function(){de.valHooks[this]={set:function(e,t){if(de.isArray(t))return e.checked=de.inArray(de(e).val(),t)>-1}},pe.checkOn||(de.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})});var Tt=/^(?:focusinfocus|focusoutblur)$/;de.extend(de.event,{trigger:function(t,n,r,o){var i,s,a,u,c,l,f,p=[r||te],h=ce.call(t,"type")?t.type:t,d=ce.call(t,"namespace")?t.namespace.split("."):[];if(s=a=r=r||te,3!==r.nodeType&&8!==r.nodeType&&!Tt.test(h+de.event.triggered)&&(h.indexOf(".")>-1&&(d=h.split("."),h=d.shift(),d.sort()),c=h.indexOf(":")<0&&"on"+h,t=t[de.expando]?t:new de.Event(h,"object"==typeof t&&t),t.isTrigger=o?2:3,t.namespace=d.join("."),t.rnamespace=t.namespace?new RegExp("(^|\\.)"+d.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,t.result=void 0,t.target||(t.target=r),n=null==n?[t]:de.makeArray(n,[t]),f=de.event.special[h]||{},o||!f.trigger||f.trigger.apply(r,n)!==!1)){if(!o&&!f.noBubble&&!de.isWindow(r)){for(u=f.delegateType||h,Tt.test(u+h)||(s=s.parentNode);s;s=s.parentNode)p.push(s),a=s;a===(r.ownerDocument||te)&&p.push(a.defaultView||a.parentWindow||e)}for(i=0;(s=p[i++])&&!t.isPropagationStopped();)t.type=i>1?u:f.bindType||h,l=(Fe.get(s,"events")||{})[t.type]&&Fe.get(s,"handle"),l&&l.apply(s,n),l=c&&s[c],l&&l.apply&&He(s)&&(t.result=l.apply(s,n),t.result===!1&&t.preventDefault());return t.type=h,o||t.isDefaultPrevented()||f._default&&f._default.apply(p.pop(),n)!==!1||!He(r)||c&&de.isFunction(r[h])&&!de.isWindow(r)&&(a=r[c],a&&(r[c]=null),de.event.triggered=h,r[h](),de.event.triggered=void 0,a&&(r[c]=a)),t.result}},simulate:function(e,t,n){var r=de.extend(new de.Event,n,{type:e,isSimulated:!0});de.event.trigger(r,null,t)}}),de.fn.extend({trigger:function(e,t){return this.each(function(){de.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return de.event.trigger(e,t,n,!0)}}),de.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,t){de.fn[t]=function(e,n){return arguments.length>0?this.on(t,null,e,n):this.trigger(t)}}),de.fn.extend({hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),pe.focusin="onfocusin"in e,pe.focusin||de.each({focus:"focusin",blur:"focusout"},function(e,t){var n=function(e){de.event.simulate(t,e.target,de.event.fix(e))};de.event.special[t]={setup:function(){var r=this.ownerDocument||this,o=Fe.access(r,t);o||r.addEventListener(e,n,!0),Fe.access(r,t,(o||0)+1)},teardown:function(){var r=this.ownerDocument||this,o=Fe.access(r,t)-1;o?Fe.access(r,t,o):(r.removeEventListener(e,n,!0),Fe.remove(r,t))}}});var Ct=e.location,jt=de.now(),kt=/\?/;de.parseXML=function(t){var n;if(!t||"string"!=typeof t)return null;try{n=(new e.DOMParser).parseFromString(t,"text/xml")}catch(e){n=void 0}return n&&!n.getElementsByTagName("parsererror").length||de.error("Invalid XML: "+t),n};var Et=/\[\]$/,St=/\r?\n/g,Nt=/^(?:submit|button|image|reset|file)$/i,At=/^(?:input|select|textarea|keygen)/i;de.param=function(e,t){var n,r=[],o=function(e,t){var n=de.isFunction(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(de.isArray(e)||e.jquery&&!de.isPlainObject(e))de.each(e,function(){o(this.name,this.value)});else for(n in e)V(n,e[n],t,o);return r.join("&")},de.fn.extend({serialize:function(){return de.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=de.prop(this,"elements");return e?de.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!de(this).is(":disabled")&&At.test(this.nodeName)&&!Nt.test(e)&&(this.checked||!ze.test(e))}).map(function(e,t){var n=de(this).val();return null==n?null:de.isArray(n)?de.map(n,function(e){return{name:t.name,value:e.replace(St,"\r\n")}}):{name:t.name,value:n.replace(St,"\r\n")}}).get()}});var qt=/%20/g,Dt=/#.*$/,Ot=/([?&])_=[^&]*/,Lt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Ht=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Ft=/^(?:GET|HEAD)$/,Rt=/^\/\//,It={},Pt={},Mt="*/".concat("*"),$t=te.createElement("a");$t.href=Ct.href,de.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Ct.href,type:"GET",isLocal:Ht.test(Ct.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Mt,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":de.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?Q(Q(e,de.ajaxSettings),t):Q(de.ajaxSettings,e)},ajaxPrefilter:G(It),ajaxTransport:G(Pt),ajax:function(t,n){function r(t,n,r,a){var c,p,h,b,w,T=n;l||(l=!0,u&&e.clearTimeout(u),o=void 0,s=a||"",C.readyState=t>0?4:0,c=t>=200&&t<300||304===t,r&&(b=J(d,C,r)),b=K(d,b,C,c),c?(d.ifModified&&(w=C.getResponseHeader("Last-Modified"),w&&(de.lastModified[i]=w),w=C.getResponseHeader("etag"),w&&(de.etag[i]=w)),204===t||"HEAD"===d.type?T="nocontent":304===t?T="notmodified":(T=b.state,p=b.data,h=b.error,c=!h)):(h=T,!t&&T||(T="error",t<0&&(t=0))),C.status=t,C.statusText=(n||T)+"",c?v.resolveWith(g,[p,T,C]):v.rejectWith(g,[C,T,h]),C.statusCode(x),x=void 0,f&&m.trigger(c?"ajaxSuccess":"ajaxError",[C,d,c?p:h]),y.fireWith(g,[C,T]),f&&(m.trigger("ajaxComplete",[C,d]),--de.active||de.event.trigger("ajaxStop")))}"object"==typeof t&&(n=t,t=void 0),n=n||{};var o,i,s,a,u,c,l,f,p,h,d=de.ajaxSetup({},n),g=d.context||d,m=d.context&&(g.nodeType||g.jquery)?de(g):de.event,v=de.Deferred(),y=de.Callbacks("once memory"),x=d.statusCode||{},b={},w={},T="canceled",C={readyState:0,getResponseHeader:function(e){var t;if(l){if(!a)for(a={};t=Lt.exec(s);)a[t[1].toLowerCase()]=t[2];t=a[e.toLowerCase()]}return null==t?null:t},getAllResponseHeaders:function(){return l?s:null},setRequestHeader:function(e,t){return null==l&&(e=w[e.toLowerCase()]=w[e.toLowerCase()]||e,b[e]=t),this},overrideMimeType:function(e){return null==l&&(d.mimeType=e),this},statusCode:function(e){var t;if(e)if(l)C.always(e[C.status]);else for(t in e)x[t]=[x[t],e[t]];return this},abort:function(e){var t=e||T;return o&&o.abort(t),r(0,t),this}};if(v.promise(C),d.url=((t||d.url||Ct.href)+"").replace(Rt,Ct.protocol+"//"),d.type=n.method||n.type||d.method||d.type,d.dataTypes=(d.dataType||"*").toLowerCase().match(qe)||[""],null==d.crossDomain){c=te.createElement("a");try{c.href=d.url,c.href=c.href,d.crossDomain=$t.protocol+"//"+$t.host!=c.protocol+"//"+c.host}catch(e){d.crossDomain=!0}}if(d.data&&d.processData&&"string"!=typeof d.data&&(d.data=de.param(d.data,d.traditional)),Y(It,d,n,C),l)return C;f=de.event&&d.global,f&&0===de.active++&&de.event.trigger("ajaxStart"),d.type=d.type.toUpperCase(),d.hasContent=!Ft.test(d.type),i=d.url.replace(Dt,""),d.hasContent?d.data&&d.processData&&0===(d.contentType||"").indexOf("application/x-www-form-urlencoded")&&(d.data=d.data.replace(qt,"+")):(h=d.url.slice(i.length),d.data&&(i+=(kt.test(i)?"&":"?")+d.data,delete d.data),d.cache===!1&&(i=i.replace(Ot,"$1"),h=(kt.test(i)?"&":"?")+"_="+jt++ +h),d.url=i+h),d.ifModified&&(de.lastModified[i]&&C.setRequestHeader("If-Modified-Since",de.lastModified[i]),de.etag[i]&&C.setRequestHeader("If-None-Match",de.etag[i])),(d.data&&d.hasContent&&d.contentType!==!1||n.contentType)&&C.setRequestHeader("Content-Type",d.contentType),C.setRequestHeader("Accept",d.dataTypes[0]&&d.accepts[d.dataTypes[0]]?d.accepts[d.dataTypes[0]]+("*"!==d.dataTypes[0]?", "+Mt+"; q=0.01":""):d.accepts["*"]);for(p in d.headers)C.setRequestHeader(p,d.headers[p]);if(d.beforeSend&&(d.beforeSend.call(g,C,d)===!1||l))return C.abort();if(T="abort",y.add(d.complete),C.done(d.success),C.fail(d.error),o=Y(Pt,d,n,C)){if(C.readyState=1,f&&m.trigger("ajaxSend",[C,d]),l)return C;d.async&&d.timeout>0&&(u=e.setTimeout(function(){C.abort("timeout")},d.timeout));try{l=!1,o.send(b,r)}catch(e){if(l)throw e;r(-1,e)}}else r(-1,"No Transport");return C},getJSON:function(e,t,n){return de.get(e,t,n,"json")},getScript:function(e,t){return de.get(e,void 0,t,"script")}}),de.each(["get","post"],function(e,t){de[t]=function(e,n,r,o){return de.isFunction(n)&&(o=o||r,r=n,n=void 0),de.ajax(de.extend({url:e,type:t,dataType:o,data:n,success:r},de.isPlainObject(e)&&e))}}),de._evalUrl=function(e){return de.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,throws:!0})},de.fn.extend({wrapAll:function(e){var t;return this[0]&&(de.isFunction(e)&&(e=e.call(this[0])),t=de(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){for(var e=this;e.firstElementChild;)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(e){return de.isFunction(e)?this.each(function(t){de(this).wrapInner(e.call(this,t))}):this.each(function(){var t=de(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)})},wrap:function(e){var t=de.isFunction(e);return this.each(function(n){de(this).wrapAll(t?e.call(this,n):e)})},unwrap:function(e){return this.parent(e).not("body").each(function(){de(this).replaceWith(this.childNodes)}),this}}),de.expr.pseudos.hidden=function(e){return!de.expr.pseudos.visible(e)},de.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},de.ajaxSettings.xhr=function(){try{return new e.XMLHttpRequest}catch(e){}};var Wt={0:200,1223:204},Bt=de.ajaxSettings.xhr();pe.cors=!!Bt&&"withCredentials"in Bt,pe.ajax=Bt=!!Bt,de.ajaxTransport(function(t){var n,r;if(pe.cors||Bt&&!t.crossDomain)return{send:function(o,i){var s,a=t.xhr();if(a.open(t.type,t.url,t.async,t.username,t.password),t.xhrFields)for(s in t.xhrFields)a[s]=t.xhrFields[s];t.mimeType&&a.overrideMimeType&&a.overrideMimeType(t.mimeType),t.crossDomain||o["X-Requested-With"]||(o["X-Requested-With"]="XMLHttpRequest");for(s in o)a.setRequestHeader(s,o[s]);n=function(e){return function(){n&&(n=r=a.onload=a.onerror=a.onabort=a.onreadystatechange=null,"abort"===e?a.abort():"error"===e?"number"!=typeof a.status?i(0,"error"):i(a.status,a.statusText):i(Wt[a.status]||a.status,a.statusText,"text"!==(a.responseType||"text")||"string"!=typeof a.responseText?{binary:a.response}:{text:a.responseText},a.getAllResponseHeaders()))}},a.onload=n(),r=a.onerror=n("error"),void 0!==a.onabort?a.onabort=r:a.onreadystatechange=function(){4===a.readyState&&e.setTimeout(function(){n&&r()})},n=n("abort");try{a.send(t.hasContent&&t.data||null)}catch(e){if(n)throw e}},abort:function(){n&&n()}}}),de.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),de.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return de.globalEval(e),e}}}),de.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),de.ajaxTransport("script",function(e){if(e.crossDomain){var t,n;return{send:function(r,o){t=de(" + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/docs/book/search_index.json b/docs/book/search_index.json new file mode 100644 index 000000000..404f24e5a --- /dev/null +++ b/docs/book/search_index.json @@ -0,0 +1 @@ +{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["\"0.3.0\"","\"frameless","\"org.typelevel\"","%","%%","(e.g.","(includ","(peopl","(support","(thumb",")","++=","+1,","+=","0.13.13:","0.9.x)","2.0","2.0,","2.0.x)","2.11.x.","=",">=","add","adelbertc","against","apach","api:","are:","associ","avail","benefit","bootstrap","break","bring","build.sbt","built","cast","cat","cats\"","chang","channel","code","column","compar","compil","concept","concept:","conduct","consist","consol","contribut","contributor","creat","current","custom","customizable,","dataset","dataset\"","depend","develop","document","easi","encod","enhanc","environ","express","featur","few","file","file.","follow","frameless","framelessvers","framelessversion,","friendli","function","g8","get","giter8","github,","gitter)","ground,","http://opensource.org/licenses/apach","imario","imarios/frameless.g8","injection:","insid","instal","introduct","jeremyrsmith","kanterov","learning.","librari","librarydepend","licens","list(","load","made","maintain","merg","modules:","more","needed:","new","next","non","note","olivierblanvillain","on","overview","possibl","project","project:","proof","provid","pull","quick","rdd","referenc","requests)","requests.","requir","resolv","resolver.sonatyperepo(\"releases\")","safe","same","sbt","scala","shell","sign","signatur","similar)","simply:","spark","spark'","spark).","spark.","standard","start","still","strongli","support","type","typeddatafram","typeddataset","typeddataset:","typelevel","types.","typesaf","under","up","up,","us","val","veri","versions.","want","way","well","why?","work"],"FeatureOverview.html":["\"false\")","\"paris\")","'`citi`'","'import","'name),","'population)","'price),","'project","(a)","(automated)","(b)","(enjoy","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(in","(lyon,166500.0))","(manual)","(name:","(paris,333333.3333333333),","(string,","(u:","(up","(which","(with",")",").as[aptpricecity].show().run",").as[stats].show().run()","*","+","...","/","//","1","10,","100,","10000.0,","102|","133000.0),","2","2).as[updatedsurface]","2).show().run()","2.0","200000.0),","2229621),","2229621|","2409.6385542168673,","25,","250000.0),","250|","25|[paris,","27|","2955.5555555555557,","300000.0),","325000.0)","343629)","343629|","4391.891891891892)","4391.891891891892|","45,","4500.0,","450000.0),","450|","458","47|","50,","500715),","500715|","500|","52|","6833.333333333333|","74,","740|","76|","83,","830|","85|",":27:",":28:",":31:",":33:",":34:",":36:","=","==","=>","['citi]","[1...10]).","[_1:","[city#206,","[city,","[city:","[lyon,45,133000.0]|","[lyon,500715]|","[lyon,83,200000.0]|","[nice,343629]|","[nice,74,325000.0]|","[paris,25,250000.0]|[paris,2229621]|","[paris,50,300000.0]|[paris,2229621]|","[ratio:","^","_1|","_2:","_2|","abov","achiev","actual","ad","addit","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","agg()","aggreg","aggregated,","agree.","align.","allcities:","allcities|","allow","allowed,","allowed.","alternatives:","and/or","anoth","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartmentdetail","apartmentdetails(city:","apartmentdetails?","api","appear","appli","aptd","aptds('price)","aptds('price)))","aptds('price),","aptds('surface))","aptds('surface)).as[apartmentdetails]","aptds('surface),","aptds.agg(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)).as[updatedsurface]","apttypedds('city),","apttypedds('city).cast[double]","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.join(citiinfotypedds,","apttypedds.makeudf(pricemodifier)","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds2","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","arguments)","as:","as[t]","avail","available.","averag","averageable:","avg(aptds('price)),","avg(aptds('surface)),","avgprice:","avgprice|","avgsurface:","avgsurface|minsurface|","base","better","between","boolean","boolean)].","c:","calcul","can't","case","case.","cast","cast,","catalystcast.","catalystcast[string,","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name))","city:","cityinfo","cityinfo(city:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|surface|","class","class:","claus","clause.","code","collectset(aptds('city))","column","column:","columns:","combin","compil","compile.","compile:","compiles:","complet","comput","computations.","conf","context","continu","correspond","creat","dataset","dataset.","dataset:","defin","detail","directli","discuss","divid","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","each","easili","elid","enabl","enabled.","entir","error","error.","error:","evid","exampl","example,","example.","exist","explan","explicitli","express","extra","featur","few","field","field]","fields]","find","five","follow","form","frameless","frameless.catalystaverageable[string,out]","frameless.catalystcast[string,double]","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.functions.aggregate._","frameless.implicits.widen._","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[apartment,double])(implicit","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","function","gener","get","give","given","groupbi","groupby()","here","here.","here:","however,","id","if(nam","implicit","implicitli","import","inform","initi","input","instanc","instances:","instanti","int","int)","int).","int,","int.","int]","interest","introduc","job","join","language:postfixops.","lazi","lazy.","let'","lift","localrel","long","look","lyon]|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","macro","make","materialize.","math","matter","member","method","method.","min(aptds('surface)),","minimum","minsurface:","misspel","mistak","more","n","n:","name","name:","need","new","next","next,","nice,","nice|","nice|325000.0|","not,","note","now","on","oper","operations:","option","order","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:58)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:77)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$8.apply(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2$1.apply(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionup$1(queryplan.scala:269)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:69)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:308)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:126)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:186)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:307)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:64)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2603)","org.apache.spark.sql.dataset.select(dataset.scala:969)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:49)","org.apache.spark.sql.sparksess","org.apache.spark.{sparkconf,","overload","overview","paramet","particular","per","perform","perhap","popul","population:","postfix","prefer","preserv","price","price#208]","price,","price/surfac","price:","price:double)","price];;","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.collect.run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","proce","project","prove","rais","ratio","ratio:","ratio|","readi","referenc","repl\").set(\"spark.ui.enabled\",","requir","res17:","res6:","res7:","resolv","result","retriev","right?","row","run","run()","safe","safe,","safe.","safety,","safety.","same","scala","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala.language.postfixop","scala.language.postfixops'","scaladoc","see","seem","select","select()","selectmany()","selectmany,","seq(","seq[(string,","seq[double]","set","shapeless.tag.tagged[string(\"citi\")]","shorter","show","show()","simpl","skip","spark","spark.createdataset(apartments)","spark.implicits._","spark.sparkcontext.setloglevel(\"warn\")","spark.sqlcontext","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","sqlcontext","stack","standard","start","stat","stats(","string","string)","string),updatedsurface]","string,","string]","struct,","struct]","subset","suggests,","support","suppos","surfac","surface#207,","surface,","surface,th","surface:","symbol","syntax:","t","tell","ten","three","time","time,","top","trace):","tri","tutori","two","type","type:","typedcolumn","typeddataset","typeddataset.","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","types,","typesaf","typo","u","udf","udf(aptds('city),","udf:","unit:","unlik","unsaf","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","val","valid","valu","vector[string])","visible.","want","warning:","way","wherea","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","work","worked,","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","|","|1000|102|","|276333.3333333333|62.833333333333336|","|4500.0|450000.0|","|6000.0|300000.0|","|[paris,100,450000.0]|[paris,2229621]|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|"],"TypedDatasetVsSparkDataset.html":["\"e\")","\"java.util.date\",","\"jday\")","\"mydate\"","\"q\")","\"w\")","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","&&","'`x`'","'project","(case","(class:","(i#69l","(int,","(isnotnull(i#69l)","(look","(see","(the",")",").explain()",").select(",").show().run()","*batchedscan","*deserializetoobject","*filter","*mapel","*project","*serializefromobject","+",",","...",".appli","//","10","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10|","1|","450","770",":20:",":21:",":22:","::","=","==","===","['x]","[],","[i#69l","[i#69l,j#70]","[i#69l]","[i,","[i:","[input[0,","[isnotnull(i),","^","_1#176l]","_1|","above.","access","achiev","act","ad","allow","api","applications.","area","argument","as[long]","assum","at[long]","avoid","bar","bar(1)))","bar(i:","before.","bigint","bigint))","bigint,","bigint]","bind","both","bug","bulletproof:","captur","case","cast","cast(10","catalyst","class","class:","classes)","clearli","closur","closures.","code","code.","column","columnar","columns,","columns:","compar","comparison,","compil","compromis","content","context","correct.","correctli","creat","current","dataset","dataset.","dataset[long].","datasets,","defin","detail.","detect","differ","discuss","discussion.","disk","doesn't","ds","ds.filter($\"i\"","ds.filter(_.i","ds.show()","ds:","each","elid","encod","encoder:","entir","equalto(i,10)],","error","error:","etc)","exampl","example,","exist","explain","explicitli","express","extrem","e|","fail","failure:","familiar","fd","fds('i)","fds('x)","fds.filter(","fds:","few","field","fields.","file","file.","file:/tmp/foo,","filter","filteredd","filteredds.explain()","filteredds.show()","filteredds:","find","first","first,","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo,","foo.","format","format:","found","frameless","frameless'","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[mydate]","friend.","fulli","function","futur","generated.","give","given","goal:","great!","guard","handhold","help","here","here.","hold","however,","implement","implicit","import","improv","incompat","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","input","inputpaths:","insid","int)","introduc","intuitively,","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date(system.currenttimemillis))))","java.util.date)","j|","know","last","lead","let'","limit","line","linux","load","long","long,","look","mac","map","member","members.","mention","mistak","more","mydat","mydate(jday:","name","name:","need","newinstance(class","next","nil","non","note","notifi","now,","obj#103:","obj#104:","ok","on","oper","optim","optimizer)","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:58)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:77)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:61)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$8.apply(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2$1.apply(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionup$1(queryplan.scala:269)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:592)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:598)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:425)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:69)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:308)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:126)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:186)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:307)","org.apache.spark.sql.dataset.(dataset.scala:161)","org.apache.spark.sql.dataset.(dataset.scala:167)","org.apache.spark.sql.dataset.select(dataset.scala:1023)","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:274)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:49)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:47)","os","paramet","parquet","parquetformat,","partial","partitionfilters:","pass","performance.","physic","plan","plan,","plan.","plan:","popular","practic","primit","problem","problem.","product","product,","provid","pushedfilters:","queri","quick","q|","read","readschema).","readschema:","refer","relation[i#69l,j#70]","releases.","remind","requir","resolv","return","root","run","runtim","safe","safe.","safety!","safety.","save","scala","scala.","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala>","schema","second,","see","select","select()","separately,","serial","serv","set","shapeless.tag.tagged[string(\"x\")]","show","simpl","simplist","slow","small","solut","solv","spark","spark'","spark.","spark.createdataset(","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark:","sparksess","standard","statement","statement).","store","string)","string,","string]","struct","subset","suffici","support","symbol","syntax","syntax.","take","thing","this.","time","time.","time:","togeth","tri","true]","tutori","two","type","type.","typedcolumn","typeddataset","typeddataset.","typeddataset.create(ds)","typeddataset.create(seq(mydate(new","typeddatset","unabl","unfortunately,","us","val","valu","value#105l]","veri","view","want","way","well","without","work","w|","x","x:","|","|100|","|value|"],"TypedEncoder.html":["\"daterange\"","\"java.util.date\",","\"s\")","\"s\"))))","\"s\",","(a","(and","(class:","...","//","2.0)","230",":26:",":28:","=","[i:","^","annoy","approach","around","b:","bar","bar(1.1,","bar(d:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","behav","besid","call","case","class","class:","classes.","code","compil","construct","coupl","current","custom","data","data.","dataset","dataset?.","dataset[daterange]","daterange(s:","decod","defin","deriv","derived,","detect","different,","double,","ds.collect()","ds:","e:","elid","encod","encoder.","encoder:","encoders,","ensur","error","error:","exampl","example,","existence)","expected:","extend","fail","field","find","follow","foo","foo(i:","foodate(i:","found","frameless","frameless.job$$anon$4@4e32dea0","frameless.job[seq[foo]]","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless:","gener","goe","hierarchi","ident","implicit","implicitli","import","inabl","int,","intern","introduc","issues.","it'","java.lang.unsupportedoperationexception:","java.util.d","java.util.date)","java.util.date)))","java.util.date))))","java.util.date,","jvm","lead","limit","manipul","mechan","method","more","name:","new","non","note","object","onc","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:61)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:592)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:598)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:425)","org.apache.spark.sql.dataset","org.apache.spark.sql.encoders$.product(encoders.scala:274)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:47)","overflow","paramet","pass","performances.","prove","question","recurs","reflect","represent","res2:","resolut","root","run","runtim","s:","same","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala>","scalareflect","schema.","see","shapeless","shown","situat","solv","spark","spark.implicits._","spark:","sqlcontext.createdataset(seq(daterange(new","stack","standard","store","string)","string,","struct]","summari","support","t:","take","thought","time,","time.","time:","trace,","tri","type","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeencod","types.","us","val","valu","vanilla","won't","work"],"Injection.html":["$anon$1@6cd5eaec","//","09:53:10","1","2","2017))","22","3",":24:",":32:","=","=>","[age:","^","a):","again","anoth","apply(a:","apply(d:","available,","b","b):","b.","b]","bigint]","birthday:","can't,","case","cest","class","class:","compil","creat","custom","d.gettime()","datetolonginject","datetolonginjection:","def","defin","definit","encod","encoder:","error.","error:","exampl","extend","family:","femal","find","frameless._","frameless.injection$$anon$1@2ac4b462","frameless.injection$$anon$1@7a09999d","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.typeddataset[person]","frameless.typedencoder[person]","function:","gender","gender)","gender:","gendertoint:","implicit","import","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","instanc","int,","int]","invert(b:","invert(l:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date)","java.util.date))","java.util.date).gettime(),","java.util.date):","java.util.date.","less","let","let'","list(person(42,male))","list(person(42,mon","long","long)))","long):","long:","long]","look","male","male))","more","new","now","object","on","paramet","peopl","people:","person","person(age:","persond","personds:","precis","seal","seq(person(42,","seq[person]","serializ","simpl","trait","tri","type","type,","typeclass:","typeddataset,","typeddataset.create(people)","typeddataset:","typedencod","us","val","valu","verbos","{","}","})","},"],"Job.html":["(a","(sample:","//","1","20%","20)","=","[_1:","above)","allow","along","annotate/nam","applic","be","block","calcul","collect","compar","complex","compos","composit","comprehens","comput","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","count","countandtakejob","def","description.","differ","driver","ds","ds:","easier","element","elements:","exactli","exampl","execut","expens","explicit","explicitli","few","finaljob","finaljob.","finaljob:","first","frameless.job","frameless.job$$anon$2@7b8ecc47","frameless.job[int]","frameless.job[seq[int]])frameless.job[int]","frameless.typeddataset[int]","functions:","further","group","have","help","id","import","inform","int","int]","issues.","job","job[a]","job[a],","job[int]","job[seq[int]]):","jobs.","lazi","lazili","lazy,","lazy.","make","min\").","monad","more","new","non","now","obviou","oper","part","pass","perform","place","predict","program","programm","provid","res2:","result","return","run","run()","sample.map(_.min)","say,","see","sequenc","serv","sever","show","showcas","size","spark","spark.","specifi","strict","toy","track","track,","transform","typeddataset","typeddataset.create(1","ui","us","val","via","withdescription(\"sampl","withgroupid(\"samplingjob\").","{"],"Cats.html":["\"task2\"","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(1,","(1,2,3)","(10,9,9)","(8,","(8,2,3)","(and","(chris,map(0","(john,map(0","(sam,map(0","(semigroup)",")","//","1","1)","1))","1)),","1),","1,","10))","10,","100)","11))","12)","12,","15)))","2","2)","2))","2)),","2,","20)","20,","3)","3))","3,","32,","4))","4)),","4,","5,","6,",":21",":22",":24",":26","::","=",">","aggreg","alia","alias","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","anna","arbitrari","arity.","array((joe,map(0","array[(username,","assum","avg,","below","cat","cats.implicits.","cats.implicits._","cats:","class","collect","column","combin","common","complex","comput","data","data.","data:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","default","defin","differ","element","etc.","exampl","example,","example:","execut","follow","frameless.cats.implicits._","frameless.cats.outer._","full","general).","group","implicit","implicits.scala:18","implicits.scala:43","import","int","int)]","int,","joe","join","key","key.","keys.","larg","leverag","makerdd","map(\"task1\"","map(\"task3\"","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[10]","mapvalu","max,","meaning","min,","more","nil","nil)","note","offer","on","oper","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","outer","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","pair","parallelcollectionrdd[0]","parallelcollectionrdd[1]","parallelcollectionrdd[3]","parallelcollectionrdd[5]","parallelcollectionrdd[6]","predicates.","previous","println(data.cmax)","println(data.cmin)","println(data.csum)","rdd","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","reducebykey","res10:","res11:","res7:","res8:","same","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala.collection.immutable.map[string,int])]","scala.collection.map[string,scala.collection.immutable.map[string,int]]","scala.collection.map[user,transactioncount]","section","semigroup","set","show","shuffledrdd[2]","shuffledrdd[4]","simplifi","sort","spark","string","task","task2","task3","timeseri","timeseries)]","together.","totalperus","totalperuser.collectasmap","totalperuser:","transactioncount","transactioncount)]","tupl","type","type.","us","user","user'","usernam","val","valu","way","work","|+|"],"TypedDataFrame.html":["\"dummy\"","\"unique\"","').map(r","'_4)","'q',","'s)","'x',","'z'))","'z'.","(((((((((","(implicit","(phonebooktf:",")",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","//","1.6","1.6+,","1.6,","11","2.10,","2.11","2.11,","22.",":",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","=>","???","addit","address","address,","address:","alphabet:","alternatively,","amount","api","approach","approxim","ariti","avail","away:","b:","bar(i:","be","bestneighborhood","boolean","boolean)","boolean):","boolean)]","boolean,","both","bring","c:","call","case","catch","caus","citi","citymapentry(","citymaptf:","class","column","columns.","come","common","commonli","compar","compat","compil","complet","comput","concept:","consid","consist","contain","conveni","correct","cough","count:","d:","data,","datafram","dataframe,","dataframes,","dataset","def","defin","definit","deprec","design","develop","differ","directli","dive","documented.","domain","done","doubl","double,","due","each","earli","element","enough","ensur","essenti","everyth","exampl","example:","except","execut","exist","expect","f","f.neighborhood))","f.residents.split('","fact","family(residents:","field","filter(conditionexpr:","first","flat","focu","follow","foo(s:","frameless","frameless.","frameless.typeddatafram","frameless:","function","further","futur","get","go","goal","goe","handl","have","here","hold","however,","i:","ident","import","improv","inform","instead","int)","int,","interest","intermedi","introduc","introduct","j:","job","jobs.","join","join1(tf1:","join2(tf1:","joins,","keep","languag","less","let","let'","letter","level","leverag","librari","like,","limit","limitations.","line","long)","long)])","look","main","manag","manipul","manner.","map","mirror","mistak","model","moder","more","much","name","name.exists(set('x',","names,","natur","need","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","nlplib","nlplib.uniquename(p.name)","now","number,","object","obtain","ontypeddataframe.","onward.","org.apache.spark.sql.datafram","org.apache.spark.sql.sqlcontext","p","packag","pair","person(name:","person(r,","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","point,","possibl","process","product.","proof","provid","public","readability.","readabl","reasons,","refer","referenc","represent","residents:","result","rethought","return","right","sadly,","safe","safety.","scala","schema","schema.","second","see","see,","seem","select","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","shadow","shapeless.hlist","signatures:","similar","simplifi","singl","spark","spark'","spark,","sqlcontext):","stage","still","store","string","string):","string)]","string)])","string,","suppos","syntax","syntaxes,","system","systems,","tabl","table,","tables:","target","tdataframe[schema","tdataframe[schema]","techniqu","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","time.","track","troubl","tuple23","two","type","type,","type.","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry]","typeddataframe[citymapentry])","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","types:","typo,","uniqu","uniquename(name:","us","user","valu","vanilla","variou","veri","version","way","well,","won't","work","zero.","{","}"]},"length":8},"tokenStore":{"root":{"0":{"9":{"docs":{},":":{"5":{"3":{"docs":{},":":{"1":{"0":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{},".":{"1":{"3":{"docs":{},".":{"1":{"3":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"docs":{}},"docs":{}}},"docs":{}},"9":{"docs":{},".":{"docs":{},"x":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}},"docs":{}}},"1":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"i":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.017391304347826087}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.013043478260869565}}},".":{"6":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"+":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"docs":{}}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"1":{"7":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"docs":{}},"docs":{},"%":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"3":{"0":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"docs":{}},"4":{"0":{"9":{"docs":{},".":{"6":{"3":{"8":{"5":{"5":{"4":{"2":{"1":{"6":{"8":{"6":{"7":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"9":{"5":{"5":{"docs":{},".":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},".":{"docs":{},"x":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"1":{"0":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{},"x":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"docs":{}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}}}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"4":{"3":{"6":{"2":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"4":{"3":{"9":{"1":{"docs":{},".":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"8":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"6":{"8":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"7":{"4":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"7":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"docs":{}},"docs":{}},"8":{"3":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{},"\"":{"0":{"docs":{},".":{"3":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"docs":{}}},"docs":{}}},"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"q":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"w":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"y":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"2":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"docs":{}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"%":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}},"%":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}}},"(":{"1":{"0":{"docs":{},",":{"9":{"docs":{},",":{"9":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}},"docs":{}}},"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"8":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"y":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}},"t":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"#":{"6":{"9":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}},"docs":{}},"docs":{}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"6":{"9":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}},"e":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"b":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"1":{"6":{"6":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"u":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}}}},"\"":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}}}}},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}}}}},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}}},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}},"+":{"1":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0622906898861353},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.04267589388696655}},"+":{"docs":{},"=":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"=":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"=":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.03415941058271936},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01384083044982699},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.024922118380062305},"Injection.html":{"ref":"Injection.html","tf":0.06349206349206349},"Job.html":{"ref":"Job.html","tf":0.040229885057471264},"Cats.html":{"ref":"Cats.html","tf":0.05217391304347826},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.016605166051660517}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.011534025374855825}},"=":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495}}}},">":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}},">":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.08695652173913043}},"=":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"e":{"docs":{},"l":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"d":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}},"s":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"3":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"(":{"docs":{},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"[":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},"e":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"b":{"docs":{},"o":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Job.html":{"ref":"Job.html","tf":0.017241379310344827}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"n":{"docs":{},"o":{"docs":{},"y":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"t":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"b":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"docs":{}}},"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"(":{"1":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"docs":{}},"docs":{}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007367716008037508},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.024922118380062305},"Injection.html":{"ref":"Injection.html","tf":0.04126984126984127},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01845018450184502}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.018691588785046728},"Cats.html":{"ref":"Cats.html","tf":3.339855072463768}},"s":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"u":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012915129151291513}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.502306805074971},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"x":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}}}}}},"o":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351783517835174}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"o":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Injection.html":{"ref":"Injection.html","tf":2.5126984126984127}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":2.503174603174603}},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.010716677829872739},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010380622837370242},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03426791277258567},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.02214022140221402}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"u":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.018691588785046728},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5092272202998847},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"\"":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"?":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012915129151291513}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}}}}}}}}},"y":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"f":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014760147601476014}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.03492063492063492},"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018691588785046728}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"e":{"docs":{},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"_":{"docs":{},".":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.021806853582554516},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"u":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.014018691588785047},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3551401869158877},"Injection.html":{"ref":"Injection.html","tf":2.5126984126984127}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"s":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"t":{"docs":{},"i":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"s":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"i":{"docs":{},",":{"1":{"0":{"docs":{},")":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"docs":{}},"docs":{}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.334672918062067}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}},":":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}}},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},"a":{"docs":{},"l":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"c":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.04205607476635514},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3426791277258565},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}}}}}}}}}}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"2":{"docs":{},"a":{"docs":{},"c":{"4":{"docs":{},"b":{"4":{"6":{"2":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}},"7":{"docs":{},"a":{"0":{"9":{"9":{"9":{"9":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"2":{"docs":{},"@":{"7":{"docs":{},"b":{"8":{"docs":{},"e":{"docs":{},"c":{"docs":{},"c":{"4":{"7":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"docs":{}},"docs":{}}}}},"docs":{}}},"docs":{}}},"4":{"docs":{},"@":{"4":{"docs":{},"e":{"3":{"2":{"docs":{},"d":{"docs":{},"e":{"docs":{},"a":{"0":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"docs":{}}}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"_":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}}}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"s":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495}}}},"x":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"l":{"docs":{},")":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015873015873015872}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}}},"t":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"8":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},"docs":{}}},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"p":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"b":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}},"o":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"a":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"l":{"docs":{},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"v":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"s":{"docs":{},"/":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}},"docs":{}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152},"Injection.html":{"ref":"Injection.html","tf":0.015873015873015872},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"docs":{}},"4":{"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}},"docs":{}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008707300736771601},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.017391304347826087},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015873015873015872}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"Injection.html":{"ref":"Injection.html","tf":2.503174603174603}}},"(":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},"n":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"t":{"docs":{"./":{"ref":"./","tf":10},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"l":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"f":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"t":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"j":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"y":{"docs":{},"r":{"docs":{},"s":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.022988505747126436},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":10.005747126436782}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"n":{"1":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}}}}},"2":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01107011070110701}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"l":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.01557632398753894}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"v":{"docs":{},"m":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"e":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"s":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}}}}},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.018691588785046728}}}}}},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"o":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"docs":{}},"docs":{}}}}}}}}}}},"f":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"u":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"o":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},":":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"y":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"r":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"8":{"2":{"docs":{},".":{"5":{"9":{"7":{"0":{"5":{"4":{"8":{"8":{"6":{"2":{"1":{"1":{"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"m":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"r":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"Job.html":{"ref":"Job.html","tf":0.022988505747126436}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.013043478260869565}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}},"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}},"3":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"docs":{}}}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"0":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"n":{"docs":{},"i":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"e":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"x":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"e":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007367716008037508},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"a":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"u":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"e":{"docs":{},"(":{"docs":{},"j":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018691588785046728},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}},"x":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"t":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"v":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}}}}}}}}}}},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"c":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3340031256977003}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Job.html":{"ref":"Job.html","tf":0.028735632183908046},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00922722029988466}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"$":{"2":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"7":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"8":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"2":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"2":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"$":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"0":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"0":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"9":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"8":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"9":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"8":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"9":{"8":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"$":{"docs":{},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"$":{"docs":{},"$":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"0":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"2":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}},"9":{"6":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"6":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"$":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"{":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},".":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"j":{"docs":{},"#":{"1":{"0":{"3":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.018691588785046728},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"o":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351783517835174}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}},"#":{"2":{"0":{"8":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"/":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"b":{"docs":{},"y":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"3":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"1":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"3":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"5":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"6":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"i":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.012687427912341407}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"i":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"s":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}},"(":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905}},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"t":{"docs":{},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"c":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"Cats.html":{"ref":"Cats.html","tf":3.3376811594202898}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"i":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}},"s":{"1":{"0":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"1":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"2":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"8":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"a":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"u":{"docs":{},"i":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"#":{"6":{"9":{"docs":{},"l":{"docs":{},",":{"docs":{},"j":{"docs":{},"#":{"7":{"0":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}},"o":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"m":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"y":{"docs":{},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"d":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.018691588785046728}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"5":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"9":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"s":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},">":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"2":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"4":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"y":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"z":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.018691588785046728},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01384083044982699},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Job.html":{"ref":"Job.html","tf":0.034482758620689655},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01845018450184502}},"'":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5046136101499425},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},")":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"[":{"docs":{},"*":{"docs":{},"]":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"g":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},",":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.014735432016075016},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014760147601476014}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"#":{"2":{"0":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007367716008037508}}}}}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"[":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.017241379310344827}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"i":{"docs":{},"z":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.018691588785046728},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.010046885465505693},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0196078431372549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Cats.html":{"ref":"Cats.html","tf":0.02391304347826087},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.027675276752767528}},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.34440344403444}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"p":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5034602076124566},"Job.html":{"ref":"Job.html","tf":0.022988505747126436}},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3353427104264344},"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"docs":{}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905}}}}}}}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"[":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}},"u":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"a":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.014018691588785047},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}}}},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"u":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"p":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"2":{"3":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"docs":{}},"docs":{}}}}},"w":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{},"k":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}},"f":{"1":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"j":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"2":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"j":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"i":{"docs":{},"t":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}}},"p":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{"./":{"ref":"./","tf":0.028037383177570093},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"Job.html":{"ref":"Job.html","tf":0.017241379310344827},"Cats.html":{"ref":"Cats.html","tf":3.339855072463768},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.00922509225092251}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"'":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}},"d":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.018754186202277295},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018691588785046728},"Injection.html":{"ref":"Injection.html","tf":0.03492063492063492},"Job.html":{"ref":"Job.html","tf":0.017241379310344827},"Cats.html":{"ref":"Cats.html","tf":0.017391304347826087}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},"#":{"1":{"0":{"5":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"docs":{}},"docs":{}},"docs":{}}}}},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"a":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"y":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"h":{"docs":{},"y":{"docs":{},"?":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"(":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"'":{"docs":{},"`":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"x":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"_":{"4":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"q":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"z":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"*":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"b":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006028131279303416},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"_":{"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"docs":{}}}}}}},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.12391158740790355},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.08419838523644751},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.06666666666666667},"Job.html":{"ref":"Job.html","tf":0.028735632183908046},"Cats.html":{"ref":"Cats.html","tf":0.05},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},":":{"2":{"0":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"4":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"6":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"3":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"2":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"4":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Cats.html":{"ref":"Cats.html","tf":0.0391304347826087}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"[":{"1":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"1":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"docs":{}},"docs":{}}}}},"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"x":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"_":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"docs":{}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"#":{"2":{"0":{"6":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006697923643670462}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"4":{"5":{"docs":{},",":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"8":{"3":{"docs":{},",":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"4":{"3":{"6":{"2":{"9":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"7":{"4":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"5":{"docs":{},",":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"5":{"0":{"docs":{},",":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}},"i":{"docs":{},"#":{"6":{"9":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},",":{"docs":{},"j":{"docs":{},"#":{"7":{"0":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"[":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}}}}}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}},"^":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008037508372404554},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},"_":{"1":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"#":{"1":{"7":{"6":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"docs":{}},"docs":{}},"docs":{}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}},"docs":{}},"|":{"1":{"0":{"0":{"0":{"docs":{},"|":{"1":{"0":{"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"2":{"7":{"6":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"6":{"2":{"docs":{},".":{"8":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.01808439383791025},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00922722029988466}},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"1":{"0":{"0":{"docs":{},",":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"+":{"docs":{},"|":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}}},"$":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"1":{"4":{"docs":{},".":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"6":{"docs":{},"c":{"docs":{},"d":{"5":{"docs":{},"e":{"docs":{},"a":{"docs":{},"e":{"docs":{},"c":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"docs":{}}}},"docs":{}}},"docs":{}}}}}}},"&":{"docs":{},"&":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"{":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},"}":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"?":{"docs":{},"?":{"docs":{},"?":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"length":2210},"corpusTokens":["\"0.3.0\"","\"daterange\"","\"dummy\"","\"e\")","\"false\")","\"frameless","\"java.util.date\",","\"jday\")","\"mydate\"","\"org.typelevel\"","\"paris\")","\"q\")","\"s\")","\"s\"))))","\"s\",","\"task2\"","\"unique\"","\"w\")","$anon$1@6cd5eaec","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","%","%%","&&","').map(r","'_4)","'`citi`'","'`x`'","'import","'name),","'population)","'price),","'project","'q',","'s)","'x',","'z'))","'z'.","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(((((((((","(1,","(1,2,3)","(10,9,9)","(8,","(8,2,3)","(a","(a)","(and","(automated)","(b)","(case","(chris,map(0","(class:","(e.g.","(enjoy","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(i#69l","(implicit","(in","(includ","(int,","(isnotnull(i#69l)","(john,map(0","(look","(lyon,166500.0))","(manual)","(name:","(paris,333333.3333333333),","(peopl","(phonebooktf:","(sam,map(0","(sample:","(see","(semigroup)","(string,","(support","(the","(thumb","(u:","(up","(which","(with",")",").as[aptpricecity].show().run",").as[stats].show().run()",").explain()",").select(",").show().run()","*","*batchedscan","*deserializetoobject","*filter","*mapel","*project","*serializefromobject","+","++=","+1,","+=",",","...",".appli",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","/","//","0.13.13:","0.9.x)","09:53:10","1","1)","1))","1)),","1),","1,","1.6","1.6+,","1.6,","10","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10,","100)","100,","10000.0,","102|","10|","11","11))","12)","12,","133000.0),","15)))","1|","2","2)","2))","2)),","2).as[updatedsurface]","2).show().run()","2,","2.0","2.0)","2.0,","2.0.x)","2.10,","2.11","2.11,","2.11.x.","20%","20)","20,","200000.0),","2017))","22","22.","2229621),","2229621|","230","2409.6385542168673,","25,","250000.0),","250|","25|[paris,","27|","2955.5555555555557,","3","3)","3))","3,","300000.0),","32,","325000.0)","343629)","343629|","4))","4)),","4,","4391.891891891892)","4391.891891891892|","45,","450","4500.0,","450000.0),","450|","458","47|","5,","50,","500715),","500715|","500|","52|","6,","6833.333333333333|","74,","740|","76|","770","83,","830|","85|",":",":20:",":21",":21:",":22",":22:",":24",":24:",":26",":26:",":27:",":28:",":31:",":32:",":33:",":34:",":36:","::",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","==","===","=>",">",">=","???","['citi]","['x]","[1...10]).","[],","[_1:","[age:","[city#206,","[city,","[city:","[i#69l","[i#69l,j#70]","[i#69l]","[i,","[i:","[input[0,","[isnotnull(i),","[lyon,45,133000.0]|","[lyon,500715]|","[lyon,83,200000.0]|","[nice,343629]|","[nice,74,325000.0]|","[paris,25,250000.0]|[paris,2229621]|","[paris,50,300000.0]|[paris,2229621]|","[ratio:","^","_1#176l]","_1|","_2:","_2|","a):","abov","above)","above.","access","achiev","act","actual","ad","add","addit","address","address,","address:","adelbertc","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","against","agg()","aggreg","aggregated,","agree.","alia","alias","align.","allcities:","allcities|","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","allowed,","allowed.","along","alphabet:","alternatively,","alternatives:","amount","and/or","anna","annotate/nam","annoy","anoth","apach","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartmentdetail","apartmentdetails(city:","apartmentdetails?","api","api:","appear","appli","applic","applications.","apply(a:","apply(d:","approach","approxim","aptd","aptds('price)","aptds('price)))","aptds('price),","aptds('surface))","aptds('surface)).as[apartmentdetails]","aptds('surface),","aptds.agg(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)).as[updatedsurface]","apttypedds('city),","apttypedds('city).cast[double]","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.join(citiinfotypedds,","apttypedds.makeudf(pricemodifier)","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds2","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","are:","area","argument","arguments)","ariti","arity.","around","array((joe,map(0","array[(username,","as:","as[long]","as[t]","associ","assum","at[long]","avail","available,","available.","averag","averageable:","avg(aptds('price)),","avg(aptds('surface)),","avg,","avgprice:","avgprice|","avgsurface:","avgsurface|minsurface|","avoid","away:","b","b):","b.","b:","b]","bar","bar(1)))","bar(1.1,","bar(d:","bar(i:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","before.","behav","below","benefit","besid","bestneighborhood","better","between","bigint","bigint))","bigint,","bigint]","bind","birthday:","block","boolean","boolean)","boolean):","boolean)]","boolean)].","boolean,","bootstrap","both","break","bring","bug","build.sbt","built","bulletproof:","c:","calcul","call","can't","can't,","captur","case","case.","cast","cast(10","cast,","cat","catalyst","catalystcast.","catalystcast[string,","catch","cats\"","cats.implicits.","cats.implicits._","cats:","caus","cest","chang","channel","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name))","city:","cityinfo","cityinfo(city:","citymapentry(","citymaptf:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|surface|","class","class:","classes)","classes.","claus","clause.","clearli","closur","closures.","code","code.","collect","collectset(aptds('city))","column","column:","columnar","columns,","columns.","columns:","combin","come","common","commonli","compar","comparison,","compat","compil","compile.","compile:","compiles:","complet","complex","compos","composit","comprehens","compromis","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","concept","concept:","conduct","conf","consid","consist","consol","construct","contain","content","context","continu","contribut","contributor","conveni","correct","correct.","correctli","correspond","cough","count","count:","countandtakejob","coupl","creat","current","custom","customizable,","d.gettime()","d:","data","data,","data.","data:","datafram","dataframe,","dataframes,","dataset","dataset\"","dataset.","dataset:","dataset?.","dataset[daterange]","dataset[long].","datasets,","daterange(s:","datetolonginject","datetolonginjection:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","decod","def","default","defin","definit","depend","deprec","deriv","derived,","description.","design","detail","detail.","detect","develop","differ","different,","directli","discuss","discussion.","disk","dive","divid","document","documented.","doesn't","domain","done","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","ds","ds.collect()","ds.filter($\"i\"","ds.filter(_.i","ds.show()","ds:","due","e:","each","earli","easi","easier","easili","element","elements:","elid","enabl","enabled.","encod","encoder.","encoder:","encoders,","enhanc","enough","ensur","entir","environ","equalto(i,10)],","error","error.","error:","essenti","etc)","etc.","everyth","evid","exactli","exampl","example,","example.","example:","except","execut","exist","existence)","expect","expected:","expens","explain","explan","explicit","explicitli","express","extend","extra","extrem","e|","f","f.neighborhood))","f.residents.split('","fact","fail","failure:","familiar","family(residents:","family:","fd","fds('i)","fds('x)","fds.filter(","fds:","featur","femal","few","field","field]","fields.","fields]","file","file.","file:/tmp/foo,","filter","filter(conditionexpr:","filteredd","filteredds.explain()","filteredds.show()","filteredds:","finaljob","finaljob.","finaljob:","find","first","first,","five","flat","focu","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo(s:","foo,","foo.","foodate(i:","form","format","format:","found","frameless","frameless'","frameless.","frameless._","frameless.catalystaverageable[string,out]","frameless.catalystcast[string,double]","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.cats.implicits._","frameless.cats.outer._","frameless.functions.aggregate._","frameless.implicits.widen._","frameless.injection$$anon$1@2ac4b462","frameless.injection$$anon$1@7a09999d","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.job","frameless.job$$anon$2@7b8ecc47","frameless.job$$anon$4@4e32dea0","frameless.job[int]","frameless.job[seq[foo]]","frameless.job[seq[int]])frameless.job[int]","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[apartment,double])(implicit","frameless.typeddatafram","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[foo]","frameless.typeddataset[int]","frameless.typeddataset[person]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless.typedencoder[mydate]","frameless.typedencoder[person]","frameless:","framelessvers","framelessversion,","friend.","friendli","full","fulli","function","function:","functions:","further","futur","g8","gender","gender)","gender:","gendertoint:","gener","general).","generated.","get","giter8","github,","gitter)","give","given","go","goal","goal:","goe","great!","ground,","group","groupbi","groupby()","guard","handhold","handl","have","help","here","here.","here:","hierarchi","hold","however,","http://opensource.org/licenses/apach","i:","id","ident","if(nam","imario","imarios/frameless.g8","implement","implicit","implicitli","implicits.scala:18","implicits.scala:43","import","improv","inabl","incompat","inform","initi","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","input","inputpaths:","insid","instal","instanc","instances:","instanti","instead","int","int)","int).","int)]","int,","int.","int]","interest","intermedi","intern","introduc","introduct","intuitively,","invert(b:","invert(l:","issues.","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date(system.currenttimemillis))))","java.util.date)","java.util.date))","java.util.date)))","java.util.date))))","java.util.date).gettime(),","java.util.date):","java.util.date,","java.util.date.","jeremyrsmith","job","job[a]","job[a],","job[int]","job[seq[int]]):","jobs.","joe","join","join1(tf1:","join2(tf1:","joins,","jvm","j|","kanterov","keep","key","key.","keys.","know","languag","language:postfixops.","larg","last","lazi","lazili","lazy,","lazy.","lead","learning.","less","let","let'","letter","level","leverag","librari","librarydepend","licens","lift","like,","limit","limitations.","line","linux","list(","list(person(42,male))","list(person(42,mon","load","localrel","long","long)","long)))","long):","long)])","long,","long:","long]","look","lyon]|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","mac","macro","made","main","maintain","make","makerdd","male","male))","manag","manipul","manner.","map","map(\"task1\"","map(\"task3\"","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[10]","mapvalu","materialize.","math","matter","max,","meaning","mechan","member","members.","mention","merg","method","method.","min\").","min(aptds('surface)),","min,","minimum","minsurface:","mirror","misspel","mistak","model","moder","modules:","monad","more","much","mydat","mydate(jday:","n","n:","name","name.exists(set('x',","name:","names,","natur","need","needed:","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","new","newinstance(class","next","next,","nice,","nice|","nice|325000.0|","nil","nil)","nlplib","nlplib.uniquename(p.name)","non","not,","note","notifi","now","now,","number,","obj#103:","obj#104:","object","obtain","obviou","offer","ok","olivierblanvillain","on","onc","ontypeddataframe.","onward.","oper","operations:","optim","optimizer)","option","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:58)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:77)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:61)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$8.apply(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2$1.apply(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionup$1(queryplan.scala:269)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:592)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:598)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:425)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:69)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:308)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:126)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:186)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:307)","org.apache.spark.sql.datafram","org.apache.spark.sql.dataset","org.apache.spark.sql.dataset$.ofrows(dataset.scala:64)","org.apache.spark.sql.dataset.(dataset.scala:161)","org.apache.spark.sql.dataset.(dataset.scala:167)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2603)","org.apache.spark.sql.dataset.select(dataset.scala:1023)","org.apache.spark.sql.dataset.select(dataset.scala:969)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:274)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:49)","org.apache.spark.sql.sparksess","org.apache.spark.sql.sqlcontext","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:47)","org.apache.spark.{sparkconf,","os","outer","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","overflow","overload","overview","p","packag","pair","parallelcollectionrdd[0]","parallelcollectionrdd[1]","parallelcollectionrdd[3]","parallelcollectionrdd[5]","parallelcollectionrdd[6]","paramet","parquet","parquetformat,","part","partial","particular","partitionfilters:","pass","peopl","people:","per","perform","performance.","performances.","perhap","person","person(age:","person(name:","person(r,","persond","personds:","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","physic","place","plan","plan,","plan.","plan:","point,","popul","popular","population:","possibl","postfix","practic","precis","predicates.","predict","prefer","preserv","previous","price","price#208]","price,","price/surfac","price:","price:double)","price];;","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.collect.run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","primit","println(data.cmax)","println(data.cmin)","println(data.csum)","problem","problem.","proce","process","product","product,","product.","program","programm","project","project:","proof","prove","provid","public","pull","pushedfilters:","queri","question","quick","q|","rais","ratio","ratio:","ratio|","rdd","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","read","readability.","readabl","readi","readschema).","readschema:","reasons,","recurs","reducebykey","refer","referenc","reflect","relation[i#69l,j#70]","releases.","remind","repl\").set(\"spark.ui.enabled\",","represent","requests)","requests.","requir","res10:","res11:","res17:","res2:","res6:","res7:","res8:","residents:","resolut","resolv","resolver.sonatyperepo(\"releases\")","result","rethought","retriev","return","right","right?","root","row","run","run()","runtim","s:","sadly,","safe","safe,","safe.","safety!","safety,","safety.","same","sample.map(_.min)","save","say,","sbt","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala","scala.","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.immutable.map[string,int])]","scala.collection.map[string,scala.collection.immutable.map[string,int]]","scala.collection.map[user,transactioncount]","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala.language.postfixop","scala.language.postfixops'","scala>","scaladoc","scalareflect","schema","schema.","seal","second","second,","section","see","see,","seem","select","select()","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","selectmany()","selectmany,","semigroup","separately,","seq(","seq(person(42,","seq[(string,","seq[double]","seq[person]","sequenc","serial","serializ","serv","set","sever","shadow","shapeless","shapeless.hlist","shapeless.tag.tagged[string(\"citi\")]","shapeless.tag.tagged[string(\"x\")]","shell","shorter","show","show()","showcas","shown","shuffledrdd[2]","shuffledrdd[4]","sign","signatur","signatures:","similar","similar)","simpl","simplifi","simplist","simply:","singl","situat","size","skip","slow","small","solut","solv","sort","spark","spark'","spark).","spark,","spark.","spark.createdataset(","spark.createdataset(apartments)","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark.sparkcontext.setloglevel(\"warn\")","spark.sqlcontext","spark:","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparksess","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","sqlcontext","sqlcontext):","sqlcontext.createdataset(seq(daterange(new","stack","stage","standard","start","stat","statement","statement).","stats(","still","store","strict","string","string)","string),updatedsurface]","string):","string)]","string)])","string,","string]","strongli","struct","struct,","struct]","subset","suffici","suggests,","summari","support","suppos","surfac","surface#207,","surface,","surface,th","surface:","symbol","syntax","syntax.","syntax:","syntaxes,","system","systems,","t","t:","tabl","table,","tables:","take","target","task","task2","task3","tdataframe[schema","tdataframe[schema]","techniqu","tell","ten","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","thing","this.","thought","three","time","time,","time.","time:","timeseri","timeseries)]","togeth","together.","top","totalperus","totalperuser.collectasmap","totalperuser:","toy","trace):","trace,","track","track,","trait","transactioncount","transactioncount)]","transform","tri","troubl","true]","tupl","tuple23","tutori","two","type","type,","type.","type:","typeclass:","typedcolumn","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry]","typeddataframe[citymapentry])","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","typeddataset","typeddataset,","typeddataset.","typeddataset.create(1","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset.create(ds)","typeddataset.create(people)","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset.create(seq(mydate(new","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","typeddatset","typedencod","typeencod","typelevel","types,","types.","types:","typesaf","typo","typo,","u","udf","udf(aptds('city),","udf:","ui","unabl","under","unfortunately,","uniqu","uniquename(name:","unit:","unlik","unsaf","up","up,","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","user'","usernam","val","valid","valu","value#105l]","vanilla","variou","vector[string])","verbos","veri","version","versions.","via","view","visible.","want","warning:","way","well","well,","wherea","why?","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withdescription(\"sampl","withgroupid(\"samplingjob\").","without","won't","work","worked,","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","w|","x","x:","zero.","{","|","|+|","|1000|102|","|100|","|276333.3333333333|62.833333333333336|","|4500.0|450000.0|","|6000.0|300000.0|","|[paris,100,450000.0]|[paris,2229621]|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|value|","}","})","},"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"Introduction","keywords":"","body":"Frameless\n\n\n\n\nFrameless is a proof-of-concept library for working with Spark using more expressive types.\nIt consists of the following modules:\n\ndataset for more strongly typed Datasets (supports Spark 2.0.x)\ncats for using Spark with cats (supports Cats 0.9.x)\n\nThe Frameless project and contributors support the\nTypelevel Code of Conduct and want all its\nassociated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning.\nDocumentation\n\nTypedDataset: Feature Overview\nComparing TypedDatasets with Spark's Datasets\nTyped Encoders in Frameless\nInjection: Creating Custom Encoders\nUsing Cats with RDDs\nProof of Concept: TypedDataFrame\n\nWhy?\nBenefits of using TypedDataset compared to the standard Spark Dataset API:\n\nTypesafe columns referencing and expressions\nCustomizable, typesafe encoders\nTypesafe casting and projections\nEnhanced type signature for some built-in functions\n\nQuick Start\nFrameless is compiled against Scala 2.11.x.\nNote that while Frameless is still getting off the ground, it is very possible that breaking changes will be\nmade for at least the next few versions.\nTo use Frameless in your project add the following in your build.sbt file as needed:\nresolvers += Resolver.sonatypeRepo(\"releases\")\n\nval framelessVersion = \"0.3.0\"\n\nlibraryDependencies ++= List(\n \"org.typelevel\" %% \"frameless-cats\" % framelessVersion,\n \"org.typelevel\" %% \"frameless-dataset\" % framelessVersion\n)\n\nAn easy way to bootstrap a Frameless sbt project:\n\nif you have Giter8 installed then simply:\n\ng8 imarios/frameless.g8\n\n\nwith sbt >= 0.13.13:\n\nsbt new imarios/frameless.g8\n\nTyping sbt console inside your project will bring up a shell with Frameless\nand all its dependencies loaded (including Spark).\nDevelopment\nWe require at least one sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers\n(people who can merge pull requests) are:\n\nadelbertc\nimarios\njeremyrsmith\nkanterov\nnon\nOlivierBlanvillain\n\nLicense\nCode is provided under the Apache 2.0 license available at http://opensource.org/licenses/Apache-2.0,\nas well as in the LICENSE file. This is the same license used as Spark.\n"},"FeatureOverview.html":{"url":"FeatureOverview.html","title":"TypedDataset: Feature Overview","keywords":"","body":"TypedDataset: Feature Overview\nThis tutorial introduces TypedDataset using a simple example.\nThe following imports are needed to make all code examples compile.\nimport org.apache.spark.{SparkConf, SparkContext}\nimport org.apache.spark.sql.SparkSession\nimport frameless.functions.aggregate._\nimport frameless.TypedDataset\n\nval conf = new SparkConf().setMaster(\"local[*]\").setAppName(\"frameless repl\").set(\"spark.ui.enabled\", \"false\")\nval spark = SparkSession.builder().config(conf).appName(\"REPL\").getOrCreate()\nimplicit val sqlContext = spark.sqlContext\nspark.sparkContext.setLogLevel(\"WARN\")\n\nimport spark.implicits._\n\nCreating TypedDataset instances\nWe start by defining a case class:\ncase class Apartment(city: String, surface: Int, price: Double)\n\nAnd few Apartment instances:\nval apartments = Seq(\n Apartment(\"Paris\", 50, 300000.0),\n Apartment(\"Paris\", 100, 450000.0),\n Apartment(\"Paris\", 25, 250000.0),\n Apartment(\"Lyon\", 83, 200000.0),\n Apartment(\"Lyon\", 45, 133000.0),\n Apartment(\"Nice\", 74, 325000.0)\n)\n\nWe are now ready to instantiate a TypedDataset[Apartment]:\nval aptTypedDs = TypedDataset.create(apartments)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nWe can also create one from an existing Spark Dataset:\nval aptDs = spark.createDataset(apartments)\n// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nval aptTypedDs = TypedDataset.create(aptDs)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nOr use the Frameless syntax:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval aptTypedDs2 = aptDs.typed\n// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nTypesafe column referencing\nThis is how we select a particular column from a TypedDataset:\nval cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))\n// cities: frameless.TypedDataset[String] = [_1: string]\n\nThis is completely type-safe, for instance suppose we misspell city as citi:\naptTypedDs.select(aptTypedDs('citi))\n// :28: error: No column Symbol with shapeless.tag.Tagged[String(\"citi\")] of type A in Apartment\n// aptTypedDs.select(aptTypedDs('citi))\n// ^\n\nThis gets raised at compile-time, whereas with the standard Dataset API the error appears at run-time (enjoy the stack trace):\naptDs.select('citi)\n// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [city, surface, price];;\n// 'Project ['citi]\n// +- LocalRelation [city#206, surface#207, price#208]\n// \n// at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:77)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:74)\n// at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n// at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n// at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:69)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:307)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionUp$1(QueryPlan.scala:269)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:279)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2$1.apply(QueryPlan.scala:283)\n// at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n// at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n// at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)\n// at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)\n// at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n// at scala.collection.AbstractTraversable.map(Traversable.scala:104)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:283)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$8.apply(QueryPlan.scala:288)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:186)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:288)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:74)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:67)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:126)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:67)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:58)\n// at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:49)\n// at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:64)\n// at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2603)\n// at org.apache.spark.sql.Dataset.select(Dataset.scala:969)\n// ... 458 elided\n\nselect() supports arbitrary column operations:\naptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()\n// +----+---+\n// | _1| _2|\n// +----+---+\n// | 500| 52|\n// |1000|102|\n// | 250| 27|\n// | 830| 85|\n// | 450| 47|\n// | 740| 76|\n// +----+---+\n//\n\nNote that unlike the standard Spark API where some operations are lazy and some are not, TypedDatasets have all operations to be lazy. \nIn the above example, show() is lazy. It requires to apply run() for the show job to materialize.\nA more detailed explanation of Job is given here.\nNext we compute the price by surface unit:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// :27: error: overloaded method value / with alternatives:\n// (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] \n// (u: frameless.TypedColumn[Apartment,Double])(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double]\n// cannot be applied to (frameless.TypedColumn[Apartment,Int])\n// val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// ^\n\nAs the error suggests, we can't divide a TypedColumn of Double by Int. \nFor safety, in Frameless only math operations between same types is allowed. \nThere are two ways to proceed here: \n(a) Explicitly cast Int to Double (manual)\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect().run()\n// res6: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\n(b) Perform the cast implicitly (automated)\nimport frameless.implicits.widen._\n// import frameless.implicits.widen._\n\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect.run()\n// res7: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\nLooks like it worked, but that cast seems unsafe right? Actually it is safe.\nLet's try to cast a TypedColumn of String to Double:\naptTypedDs('city).cast[Double]\n// :31: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]\n// aptTypedDs('city).cast[Double]\n// ^\n\nThe compile-time error tells us that to perform the cast, an evidence \n(in the form of CatalystCast[String, Double]) must be available. \nSince casting from String to Double is not allowed, this results \nin a compilation error. \nCheck here \nfor the set of available CatalystCast.\nTypeSafe TypedDataset casting and projections\nWith select() the resulting TypedDataset is of type TypedDataset[TupleN[...]] (with N in [1...10]).\nFor example, if we select three columns with types String, Int, and Boolean the result will have type\nTypedDataset[(String, Int, Boolean)]. To select more than ten columns use the selectMany() method. \nSelect has better IDE support than the macro based selectMany, so prefer select() for the general case. \nWe often want to give more expressive types to the result of our computations.\nas[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long\nas the types in U and T align.\nWhen the cast is valid the expression compiles:\ncase class UpdatedSurface(city: String, surface: Int)\n// defined class UpdatedSurface\n\nval updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]\n// updated: frameless.TypedDataset[UpdatedSurface] = [city: string, surface: int]\n\nupdated.show(2).run()\n// +-----+-------+\n// | city|surface|\n// +-----+-------+\n// |Paris| 52|\n// |Paris| 102|\n// +-----+-------+\n// only showing top 2 rows\n//\n\nNext we try to cast a (String, String) to an UpdatedSurface (which has types String, Int).\nThe cast is not valid and the expression does not compile:\naptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// :33: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]\n// aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// ^\n\nProjections\nWe often want to work with a subset of the fields in a dataset.\nProjections allows to easily select the fields we are interested\nwhile preserving their initial name and types for extra safety.\nHere is an example using the TypedDataset[Apartment] with an additional column:\nimport frameless.implicits.widen._\n// import frameless.implicits.widen._\n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\ncase class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)\n// defined class ApartmentDetails\n\nval aptWithRatio = aptds.select(aptds('city), aptds('price), aptds('surface), aptds('price) / aptds('surface)).as[ApartmentDetails]\n// aptWithRatio: frameless.TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]\n\nSuppose we only want to work with city and ratio:\ncase class CityInfo(city: String, ratio: Double)\n// defined class CityInfo\n\nval cityRatio = aptWithRatio.project[CityInfo]\n// cityRatio: frameless.TypedDataset[CityInfo] = [city: string, ratio: double]\n\ncityRatio.show(2).run()\n// +-----+------+\n// | city| ratio|\n// +-----+------+\n// |Paris|6000.0|\n// |Paris|4500.0|\n// +-----+------+\n// only showing top 2 rows\n//\n\nSuppose we only want to work with price and ratio:\ncase class PriceInfo(ratio: Double, price: Double)\n// defined class PriceInfo\n\nval priceInfo = aptWithRatio.project[PriceInfo]\n// priceInfo: frameless.TypedDataset[PriceInfo] = [ratio: double, price: double]\n\npriceInfo.show(2).run()\n// +------+--------+\n// | ratio| price|\n// +------+--------+\n// |6000.0|300000.0|\n// |4500.0|450000.0|\n// +------+--------+\n// only showing top 2 rows\n//\n\nWe see that the order of the fields does not matter as long as the\nnames and the corresponding types agree. However, if we make a mistake in\nany of the names and/or their types, then we get a compilation error.\nSay we make a typo in a field name:\ncase class PriceInfo2(ratio: Double, pricEE: Double)\n\naptWithRatio.project[PriceInfo2]\n// :36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?\n// aptWithRatio.project[PriceInfo2]\n// ^\n\nSay we make a mistake in the corresponding type:\ncase class PriceInfo3(ratio: Int, price: Double) // ratio should be Double\n\naptWithRatio.project[PriceInfo3]\n// :36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?\n// aptWithRatio.project[PriceInfo3]\n// ^\n\nUser Defined Functions\nFrameless supports lifting any Scala function (up to five arguments) to the\ncontext of a particular TypedDataset:\n// The function we want to use as UDF\nval priceModifier =\n (name: String, price:Double) => if(name == \"Paris\") price * 2.0 else price\n// priceModifier: (String, Double) => Double = \n\nval udf = aptTypedDs.makeUDF(priceModifier)\n// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = \n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nval adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))\n// adjustedPrice: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\nadjustedPrice.show().run()\n// +-----+--------+\n// | _1| _2|\n// +-----+--------+\n// |Paris|600000.0|\n// |Paris|900000.0|\n// |Paris|500000.0|\n// | Lyon|200000.0|\n// | Lyon|133000.0|\n// | Nice|325000.0|\n// +-----+--------+\n//\n\nGroupBy and Aggregations\nLet's suppose we wanted to retrieve the average apartment price in each city\nval priceByCity = aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('price)))\n// priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\npriceByCity.collect().run()\n// res17: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))\n\nAgain if we try to aggregate a column that can't be aggregated, we get a compilation error\naptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city))) ^\n// :34: error: could not find implicit value for parameter averageable: frameless.CatalystAverageable[String,Out]\n// aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city))) ^\n// ^\n// :34: warning: postfix operator ^ should be enabled\n// by making the implicit value scala.language.postfixOps visible.\n// This can be achieved by adding the import clause 'import scala.language.postfixOps'\n// or by setting the compiler option -language:postfixOps.\n// See the Scaladoc for value scala.language.postfixOps for a discussion\n// why the feature should be explicitly enabled.\n// aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city))) ^\n// ^\n\nNext, we combine select and groupBy to calculate the average price/surface ratio per city:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nval cityPriceRatio = aptds.select(aptds('city), aptds('price) / aptds('surface))\n// cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\ncityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()\n// +-----+------------------+\n// | _1| _2|\n// +-----+------------------+\n// | Nice| 4391.891891891892|\n// |Paris| 6833.333333333333|\n// | Lyon|2682.5970548862115|\n// +-----+------------------+\n//\n\nEntire TypedDataset Aggregation\nWe often want to aggregate the entire TypedDataset and skip the groupBy() clause.\nIn Frameless you can do this using the agg() operator directly on the TypedDataset. \nIn the following example, we compute the average price, the average surface,the minimum surface, and the set of cities for the entire dataset. \ncase class Stats(\n avgPrice: Double, \n avgSurface: Double, \n minSurface: Int, \n allCities: Vector[String])\n// defined class Stats\n\naptds.agg(\n avg(aptds('price)), \n avg(aptds('surface)),\n min(aptds('surface)),\n collectSet(aptds('city))\n).as[Stats].show().run() \n// +-----------------+------------------+----------+-------------------+\n// | avgPrice| avgSurface|minSurface| allCities|\n// +-----------------+------------------+----------+-------------------+\n// |276333.3333333333|62.833333333333336| 25|[Paris, Nice, Lyon]|\n// +-----------------+------------------+----------+-------------------+\n//\n\nJoins\ncase class CityPopulationInfo(name: String, population: Int)\n\nval cityInfo = Seq(\n CityPopulationInfo(\"Paris\", 2229621),\n CityPopulationInfo(\"Lyon\", 500715),\n CityPopulationInfo(\"Nice\", 343629)\n)\n\nval citiInfoTypedDS = TypedDataset.create(cityInfo)\n\nHere is how to join the population information to the apartment's dataset.\nval withCityInfo = aptTypedDs.join(citiInfoTypedDS, aptTypedDs('city), citiInfoTypedDS('name))\n// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct, _2: struct]\n\nwithCityInfo.show().run()\n// +--------------------+---------------+\n// | _1| _2|\n// +--------------------+---------------+\n// | [Paris,50,300000.0]|[Paris,2229621]|\n// |[Paris,100,450000.0]|[Paris,2229621]|\n// | [Paris,25,250000.0]|[Paris,2229621]|\n// | [Lyon,83,200000.0]| [Lyon,500715]|\n// | [Lyon,45,133000.0]| [Lyon,500715]|\n// | [Nice,74,325000.0]| [Nice,343629]|\n// +--------------------+---------------+\n//\n\nThe joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].\nWe can then select which information we want to continue to work with:\ncase class AptPriceCity(city: String, aptPrice: Double, cityPopulation: Int)\n// defined class AptPriceCity\n\nwithCityInfo.select(\n withCityInfo.colMany('_2, 'name), withCityInfo.colMany('_1, 'price), withCityInfo.colMany('_2, 'population)\n).as[AptPriceCity].show().run\n// +-----+--------+--------------+\n// | city|aptPrice|cityPopulation|\n// +-----+--------+--------------+\n// |Paris|300000.0| 2229621|\n// |Paris|450000.0| 2229621|\n// |Paris|250000.0| 2229621|\n// | Lyon|200000.0| 500715|\n// | Lyon|133000.0| 500715|\n// | Nice|325000.0| 343629|\n// +-----+--------+--------------+\n//\n\n"},"TypedDatasetVsSparkDataset.html":{"url":"TypedDatasetVsSparkDataset.html","title":"Comparing TypedDatasets with Spark's Datasets","keywords":"","body":"Comparing TypedDatasets with Spark's Datasets\nGoal:\n This tutorial compares the standard Spark Datasets api with the one provided by\n frameless' TypedDataset. It shows how TypedDatsets allows for an expressive and\n type-safe api with no compromises on performance.\nFor this tutorial we first create a simple dataset and save it on disk as a parquet file.\nParquet is a popular columnar format and well supported by Spark.\nIt's important to note that when operating on parquet datasets, Spark knows that each column is stored\nseparately, so if we only need a subset of the columns Spark will optimize for this and avoid reading\nthe entire dataset. This is a rather simplistic view of how Spark and parquet work together but it\nwill serve us well for the context of this discussion.\nimport spark.implicits._\n// import spark.implicits._\n\n// Our example case class Foo acting here as a schema\ncase class Foo(i: Long, j: String)\n// defined class Foo\n\n// Assuming spark is loaded and SparkSession is bind to spark\nval initialDs = spark.createDataset( Foo(1, \"Q\") :: Foo(10, \"W\") :: Foo(100, \"E\") :: Nil )\n// initialDs: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\n// Assuming you are on Linux or Mac OS\ninitialDs.write.parquet(\"/tmp/foo\")\n\nval ds = spark.read.parquet(\"/tmp/foo\").as[Foo]\n// ds: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\nds.show()\n// +---+---+\n// | i| j|\n// +---+---+\n// | 10| W|\n// |100| E|\n// | 1| Q|\n// +---+---+\n//\n\nThe value ds holds the content of the initialDs read from a parquet file.\nLet's try to only use field i from Foo and see how Spark's Catalyst (the query optimizer)\noptimizes this.\n// Using a standard Spark TypedColumn in select()\nval filteredDs = ds.filter($\"i\" === 10).select($\"i\".as[Long])\n// filteredDs: org.apache.spark.sql.Dataset[Long] = [i: bigint]\n\nfilteredDs.show()\n// +---+\n// | i|\n// +---+\n// | 10|\n// +---+\n//\n\nThe filteredDs is of type Dataset[Long]. Since we only access field i from Foo the type is correct.\nUnfortunately, this syntax requires handholding by explicitly setting the TypedColumn in the select statement\nto return type Long (look at the as[Long] statement). We will discuss this limitation next in more detail.\nNow, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.\nfilteredDs.explain()\n// == Physical Plan ==\n// *Project [i#69L]\n// +- *Filter (isnotnull(i#69L) && (i#69L = 10))\n// +- *BatchedScan parquet [i#69L] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nThe last line is very important (see ReadSchema). The schema read\nfrom the parquet file only required reading column i without needing to access column j.\nThis is great! We have both an optimized query plan and type-safety!\nUnfortunately, this syntax is not bulletproof: it fails at run-time if we try to access\na non existing column x:\nscala> ds.filter($\"i\" === 10).select($\"x\".as[Long])\norg.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];;\n'Project ['x]\n+- Filter (i#69L = cast(10 as bigint))\n +- Relation[i#69L,j#70] parquet\n\n at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:77)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:74)\n at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:69)\n at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:307)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionUp$1(QueryPlan.scala:269)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:279)\n at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2$1.apply(QueryPlan.scala:283)\n at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n at scala.collection.immutable.List.foreach(List.scala:392)\n at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n at scala.collection.immutable.List.map(List.scala:296)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:283)\n at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$8.apply(QueryPlan.scala:288)\n at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:186)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:288)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:74)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:67)\n at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:126)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:67)\n at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:58)\n at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:49)\n at org.apache.spark.sql.Dataset.(Dataset.scala:161)\n at org.apache.spark.sql.Dataset.(Dataset.scala:167)\n at org.apache.spark.sql.Dataset.select(Dataset.scala:1023)\n ... 450 elided\n\nThere are two things to improve here. First, we would want to avoid the at[Long] casting that we are required\nto type for type-safety. This is clearly an area where we can introduce a bug by casting to an incompatible\ntype. Second, we want a solution where reference to a\nnon existing column name fails at compilation time.\nThe standard Spark Dataset can achieve this using the following syntax.\nds.filter(_.i == 10).map(_.i).show()\n// +-----+\n// |value|\n// +-----+\n// | 10|\n// +-----+\n//\n\nThis looks great! It reminds us the familiar syntax from Scala.\nThe two closures in filter and map are functions that operate on Foo and the\ncompiler will helps us capture all the mistakes we mentioned above.\nscala> ds.filter(_.i == 10).map(_.x).show()\n:20: error: value x is not a member of Foo\n ds.filter(_.i == 10).map(_.x).show()\n ^\n\nUnfortunately, this syntax does not allow Spark to optimize the code.\nds.filter(_.i == 10).map(_.i).explain()\n// == Physical Plan ==\n// *SerializeFromObject [input[0, bigint, true] AS value#105L]\n// +- *MapElements , obj#104: bigint\n// +- *DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#103: $line14.$read$$iw$$iw$$iw$$iw$Foo\n// +- *Filter .apply\n// +- *BatchedScan parquet [i#69L,j#70] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [], ReadSchema: struct\n\nAs we see from the explained Physical Plan, Spark was not able to optimize our query as before.\nReading the parquet file will required loading all the fields of Foo. This might be ok for\nsmall datasets or for datasets with few columns, but will be extremely slow for most practical\napplications.\nIntuitively, Spark currently doesn't have a way to look inside the code we pass in these two\nclosures. It only knows that they both take one argument of type Foo, but it has no way of knowing if\nwe use just one or all of Foo's fields.\nThe TypedDataset in frameless solves this problem. It allows for a simple and type-safe syntax\nwith a fully optimized query plan.\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nval fds = TypedDataset.create(ds)\n// fds: frameless.TypedDataset[Foo] = [i: bigint, j: string]\n\nfds.filter( fds('i) === 10 ).select( fds('i) ).show().run()\n// +---+\n// | _1|\n// +---+\n// | 10|\n// +---+\n//\n\nAnd the optimized Physical Plan:\nfds.filter( fds('i) === 10 ).select( fds('i) ).explain()\n// == Physical Plan ==\n// *Project [i#69L AS _1#176L]\n// +- *Filter (isnotnull(i#69L) && (i#69L = 10))\n// +- *BatchedScan parquet [i#69L] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nAnd the compiler is our friend.\nscala> fds.filter( fds('i) === 10 ).select( fds('x) )\n:21: error: No column Symbol with shapeless.tag.Tagged[String(\"x\")] of type A in Foo\n fds.filter( fds('i) === 10 ).select( fds('x) )\n ^\n\nDifferences in Encoders\nEncoders in Spark's Datasets are partially type-safe. If you try to create a Dataset using a type that is not \n a Scala Product then you get a compilation error:\nclass Bar(i: Int)\n// defined class Bar\n\nBar is neither a case class nor a Product, so the following correctly gives a compilation error in Spark:\nscala> spark.createDataset(Seq(new Bar(1)))\n:21: error: Unable to find encoder for type stored in a Dataset. Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._ Support for serializing other types will be added in future releases.\n spark.createDataset(Seq(new Bar(1)))\n ^\n\nHowever, the compile type guards implemented in Spark are not sufficient to detect non encodable members. \nFor example, using the following case class leads to a runtime failure:\ncase class MyDate(jday: java.util.Date)\n// defined class MyDate\n\nval myDateDs = spark.createDataset(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// java.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n// - field (class: \"java.util.Date\", name: \"jday\")\n// - root class: \"MyDate\"\n// at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:598)\n// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:592)\n// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:583)\n// at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n// at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n// at scala.collection.immutable.List.foreach(List.scala:392)\n// at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n// at scala.collection.immutable.List.flatMap(List.scala:355)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:583)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:425)\n// at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:61)\n// at org.apache.spark.sql.Encoders$.product(Encoders.scala:274)\n// at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:47)\n// ... 770 elided\n\nIn comparison, a TypedDataset will notify about the encoding problem at compile time: \nTypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// :22: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[MyDate]\n// TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// ^\n\n"},"TypedEncoder.html":{"url":"TypedEncoder.html","title":"Typed Encoders in Frameless","keywords":"","body":"Typed Encoders in Frameless\nSpark uses Reflection to derive it's Encoders, which is why they can fail at run time. For example, because Spark does not supports java.util.Date, the following leads to an error:\nimport org.apache.spark.sql.Dataset\nimport spark.implicits._\n\ncase class DateRange(s: java.util.Date, e: java.util.Date)\n\nscala> val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))\njava.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n- field (class: \"java.util.Date\", name: \"s\")\n- root class: \"DateRange\"\n at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:598)\n at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:592)\n at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:583)\n at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n at scala.collection.immutable.List.foreach(List.scala:392)\n at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n at scala.collection.immutable.List.flatMap(List.scala:355)\n at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:583)\n at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:425)\n at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:61)\n at org.apache.spark.sql.Encoders$.product(Encoders.scala:274)\n at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:47)\n ... 230 elided\n\nAs shown by the stack trace, this runtime error goes thought ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection based approach is it's inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.\nFrameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the code java.util.Date example won't compile with frameless:\nimport frameless.TypedDataset\n\nval ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// :26: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]\n// val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// ^\n\nType class derivation takes case or recursively constructing (and proving the existence) TypeEncoders for case classes. The following works as expected:\ncase class Bar(d: Double, s: String)\n// defined class Bar\n\ncase class Foo(i: Int, b: Bar)\n// defined class Foo\n\nval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, \"s\"))))\n// ds: frameless.TypedDataset[Foo] = [i: int, b: struct]\n\nds.collect()\n// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@4e32dea0\n\nBut any non-encodable in the case class hierarchy will be detected at compile time:\ncase class BarDate(d: Double, s: String, t: java.util.Date)\ncase class FooDate(i: Int, b: BarDate)\n\nval ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// :28: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]\n// val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// ^\n\nIt should be noted that once derived, reflection based Encoders and implicitly derived TypeEncoders have identical performances. The derivation mechanism is different, but the objects generated to encode and decode JVM object in the Spark internal representation behave the same at run-time.\n"},"Injection.html":{"url":"Injection.html","title":"Injection: Creating Custom Encoders","keywords":"","body":"Injection: Creating Custom Encoders\nInjection lets us define encoders for types that do not have one by injecting A into an encodable type B.\nThis is the definition of the injection typeclass:\ntrait Injection[A, B] extends Serializable {\n def apply(a: A): B\n def invert(b: B): A\n}\n\nExample\nLet's define a simple case class:\ncase class Person(age: Int, birthday: java.util.Date)\n// defined class Person\n\nval people = Seq(Person(42, new java.util.Date))\n// people: Seq[Person] = List(Person(42,Mon May 22 09:53:10 CEST 2017))\n\nAnd an instance of a TypedDataset:\nval personDS = TypedDataset.create(people)\n// :24: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n// val personDS = TypedDataset.create(people)\n// ^\n\nLooks like we can't, a TypedEncoder instance of Person is not available, or more precisely for java.util.Date.\nBut we can define a injection from java.util.Date to an encodable type, like Long:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = new Injection[java.util.Date, Long] {\n def apply(d: java.util.Date): Long = d.getTime()\n def invert(l: Long): java.util.Date = new java.util.Date(l)\n}\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@6cd5eaec\n\nWe can be less verbose using the Injection.apply function:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@7a09999d\n\nNow we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, birthday: bigint]\n\nAnother example\nLet's define a sealed family:\nsealed trait Gender\n// defined trait Gender\n\ncase object Male extends Gender\n// defined object Male\n\ncase object Female extends Gender\n// defined object Female\n\ncase object Other extends Gender\n// defined object Other\n\nAnd a simple case class:\ncase class Person(age: Int, gender: Gender)\n// defined class Person\n\nval people = Seq(Person(42, Male))\n// people: Seq[Person] = List(Person(42,Male))\n\nAgain if we try to create a TypedDataset, we get a compilation error.\nval personDS = TypedDataset.create(people)\n// :32: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n// val personDS = TypedDataset.create(people)\n// ^\n\nLet's define an injection instance for Gender:\nimplicit val genderToInt: Injection[Gender, Int] = Injection(\n {\n case Male => 1\n case Female => 2\n case Other => 3\n },\n {\n case 1 => Male\n case 2 => Female\n case 3 => Other\n })\n// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@2ac4b462\n\nAnd now we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, gender: int]\n\n"},"Job.html":{"url":"Job.html","title":"Job[A]","keywords":"","body":"Job[A]\nAll operations on TypedDataset are lazy. An operation either returns a new\ntransformed TypedDataset or a Job[A], where A is the result of running a\nnon-lazy computation in Spark. Job serves several functions:\n\nMakes all operations on a TypedDataset lazy, which makes them more predictable compared to having\nfew operations being lazy and other being strict\nAllows the programmer to make expensive blocking operations explicit\nAllows for Spark jobs to be lazily sequenced using monadic composition via for-comprehension\nProvides an obvious place where you can annotate/name your Spark jobs to make it easier\nto track different parts of your application in the Spark UI\n\nThe toy example showcases the use of for-comprehension to explicitly sequences Spark Jobs.\nFirst we calculate the size of the TypedDataset and then we collect to the driver\nexactly 20% of its elements:\nval ds = TypedDataset.create(1 to 20)\n// ds: frameless.TypedDataset[Int] = [_1: int]\n\nval countAndTakeJob =\n for {\n count \nThe countAndTakeJob can either be executed using run() (as we show above) or it can\nbe passed along to other parts of the program to be further composed into more complex sequences\nof Spark jobs.\nimport frameless.Job\n// import frameless.Job\n\ndef computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min)\n// computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]\n\nval finalJob = computeMinOfSample(countAndTakeJob)\n// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@7b8ecc47\n\nNow we can execute this new job by specifying a group-id and a description.\nThis allows the programmer to see this information on the Spark UI and help track, say,\nperformance issues.\nfinalJob.\n withGroupId(\"samplingJob\").\n withDescription(\"Samples 20% of elements and computes the min\").\n run()\n// res2: Int = 1\n\n"},"Cats.html":{"url":"Cats.html","title":"Using Cats with RDDs","keywords":"","body":"Using Cats with RDDs\nData aggregation is one of the most important operations when working with Spark (and data in general).\nFor example, we often have to compute the min, max, avg, etc. from a set of columns grouped by\ndifferent predicates. This section shows how cats simplifies these tasks in Spark by\nleveraging a large collection of Type Classes for ordering and aggregating data.\nAll the examples below assume you have previously imported cats.implicits.\nimport cats.implicits._\n// import cats.implicits._\n\nCats offers ways to sort and aggregate tuples of arbitrary arity.\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nval data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[0] at makeRDD at :21\n\nprintln(data.csum)\n// (10,9,9)\n\nprintln(data.cmax)\n// (8,2,3)\n\nprintln(data.cmin)\n// (1,2,3)\n\nThe following example aggregates all the elements with a common key.\ntype User = String\n// defined type alias User\n\ntype TransactionCount = Int\n// defined type alias TransactionCount\n\nval allData: RDD[(User,TransactionCount)] =\n sc.makeRDD((\"Bob\", 12) :: (\"Joe\", 1) :: (\"Anna\", 100) :: (\"Bob\", 20) :: (\"Joe\", 2) :: Nil)\n// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[1] at makeRDD at :24\n\nval totalPerUser = allData.csumByKey\n// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[2] at reduceByKey at implicits.scala:18\n\ntotalPerUser.collectAsMap\n// res7: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)\n\nThe same example would work for more complex keys.\nval allDataComplexKeu =\n sc.makeRDD( (\"Bob\", Map(\"task1\" -> 10)) ::\n (\"Joe\", Map(\"task1\" -> 1, \"task2\" -> 3)) :: (\"Bob\", Map(\"task1\" -> 10, \"task2\" -> 1)) :: (\"Joe\", Map(\"task3\" -> 4)) :: Nil )\n// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ParallelCollectionRDD[3] at makeRDD at :22\n\nval overalTasksPerUser = allDataComplexKeu.csumByKey\n// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ShuffledRDD[4] at reduceByKey at implicits.scala:18\n\noveralTasksPerUser.collectAsMap\n// res8: scala.collection.Map[String,scala.collection.immutable.Map[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))\n\nJoins\n// Type aliases for meaningful types\ntype TimeSeries = Map[Int,Int]\n// defined type alias TimeSeries\n\ntype UserName = String\n// defined type alias UserName\n\nExample: Using the implicit full-our-join operator\nimport frameless.cats.outer._\n// import frameless.cats.outer._\n\nval day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 2, 1 -> 4)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Sam\", Map(0 -> 1)) :: Nil )\n// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[5] at makeRDD at :26\n\nval day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 10, 1 -> 11)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Joe\", Map(0 -> 1, 1 -> 2)) :: Nil )\n// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[6] at makeRDD at :26\n\nval daysCombined = day1 |+| day2\n// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[10] at mapValues at implicits.scala:43\n\ndaysCombined.collect()\n// res10: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))\n\nNote how the user's timeseries from different days have been aggregated together.\nThe |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join\non the key and combine values using the default Semigroup for the value type.\nIn cats:\nMap(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)\n// res11: Map[Int,Int] = Map(1 -> 6, 2 -> 2)\n\n"},"TypedDataFrame.html":{"url":"TypedDataFrame.html","title":"Proof of Concept: TypedDataFrame","keywords":"","body":"Proof of Concept: TypedDataFrame\nTypedDataFrame is the API developed in the early stages of frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future developments of frameless. However, the design is interesting enough for being documented.\nTo safely manipulate DataFrames we use a technique called shadow type, which consists in storing additional information about a value in a \"dummy\" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.\nDiving in\nIn TypedDataFrame, we use a single Schema to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:\nimport org.apache.spark.sql.DataFrame\nimport shapeless.HList\n\nclass TDataFrame[Schema Boolean): TDataFrame[Schema] = ???\n\n def select[C \nAs you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.\nType-level column referencing\nFor Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching column referencing at compile type. When everything goes well, frameless select is very similar to vanilla select, except that it keeps track of the selected column types:\nimport frameless.TypedDataFrame\n\ncase class Foo(s: String, d: Double, i: Int)\n\ndef selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n tf.select('i, 's)\n\nHowever, in case of typo, it gets coughs right away:\ndef selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n tf.select('j, 's)\n\nType-level joins\nJoins can available with two different syntaxes, the first lets you reference different columns on each TypedDataFrame, and ensures that their all exists and have compatible types:\ncase class Bar(i: Int, j: String, b: Boolean)\n\ndef join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =\n tf1.innerJoin(tf2).on('s).and('j)\n\nThe second syntax bring some convenience when the joining columns have identical names in both tables:\ndef join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n : TypedDataFrame[(String, Double, Int, String, Boolean)] =\n tf1.innerJoin(tf2).using('i)\n\nFurther example are available in the TypedDataFrame join tests.\nComplete example\nWe now consider a complete example to see how the type system can frameless can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city map and neighborhood:\ntype Neighborhood = String\ntype Address = String\n\ncase class PhoneBookEntry(\n address: Address,\n residents: String,\n phoneNumber: Double\n)\n\ncase class CityMapEntry(\n address: Address,\n neighborhood: Neighborhood\n)\n\nOur goal will be to compute the neighborhood with unique names, approximating \"unique\" with names containing less common\nletters in the alphabet: 'x', 'q', and 'z'. We are going to need a natural language processing library at some point, so\nlet's use the following for the example:\nobject NLPLib {\n def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))\n}\n\nSuppose we manage to obtain a TypedDataFrame[PhoneBookEntry] and a TypedDataFrame[CityMapEntry] public data, here is what our Spark job could look like with frameless:\nimport org.apache.spark.sql.SQLContext\n\n// These case classes are used to hold intermediate results\ncase class Family(residents: String, neighborhood: Neighborhood)\ncase class Person(name: String, neighborhood: Neighborhood)\ncase class NeighborhoodCount(neighborhood: Neighborhood, count: Long)\n\ndef bestNeighborhood\n (phoneBookTF: TypedDataFrame[PhoneBookEntry], cityMapTF: TypedDataFrame[CityMapEntry])\n (implicit c: SQLContext): String = {\n (((((((((\n phoneBookTF\n .innerJoin(cityMapTF).using('address) :TypedDataFrame[(Address, String, Double, String)])\n .select('_2, '_4) :TypedDataFrame[(String, String)])\n .as[Family]() :TypedDataFrame[Family])\n .flatMap { f =>\n f.residents.split(' ').map(r => Person(r, f.neighborhood))\n } :TypedDataFrame[Person])\n .filter { p =>\n NLPLib.uniqueName(p.name)\n } :TypedDataFrame[Person])\n .groupBy('neighborhood).count() :TypedDataFrame[(String, Long)])\n .as[NeighborhoodCount]() :TypedDataFrame[NeighborhoodCount])\n .sortDesc('count) :TypedDataFrame[NeighborhoodCount])\n .select('neighborhood) :TypedDataFrame[Tuple1[String]])\n .head._1\n}\n\nIf you compare this version from Spark vanilla where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.\nLimitations\nThe main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.\nIn the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.\n"}}} \ No newline at end of file diff --git a/docs/src/main/tut/README.md b/docs/src/main/tut/README.md new file mode 100644 index 000000000..adf343823 --- /dev/null +++ b/docs/src/main/tut/README.md @@ -0,0 +1,86 @@ +# Frameless + +[![Travis Badge](https://travis-ci.org/typelevel/frameless.svg?branch=master)](https://travis-ci.org/typelevel/frameless) +[![Codecov Badge](https://codecov.io/gh/typelevel/frameless/branch/master/graph/badge.svg)](https://codecov.io/gh/typelevel/frameless) +[![Maven Badge](https://img.shields.io/maven-central/v/org.typelevel/frameless-dataset_2.11.svg)](https://maven-badges.herokuapp.com/maven-central/org.typelevel/frameless-dataset_2.11) +[![Gitter Badge](https://badges.gitter.im/typelevel/frameless.svg)](https://gitter.im/typelevel/frameless) + +Frameless is a proof-of-concept library for working with [Spark](http://spark.apache.org/) using more expressive types. +It consists of the following modules: + +* `dataset` for more strongly typed `Dataset`s (supports Spark 2.0.x) +* `cats` for using Spark with [cats](https://github.com/typelevel/cats) (supports Cats 0.9.x) + + +The Frameless project and contributors support the +[Typelevel](http://typelevel.org/) [Code of Conduct](http://typelevel.org/conduct.html) and want all its +associated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning. + +## Documentation + +* [TypedDataset: Feature Overview](http://typelevel.github.io/frameless/docs/book/FeatureOverview.html) +* [Comparing TypedDatasets with Spark's Datasets](http://typelevel.github.io/frameless/docs/book/TypedDatasetVsSparkDataset.html) +* [Typed Encoders in Frameless](http://typelevel.github.io/frameless/docs/book/TypedEncoder.html) +* [Injection: Creating Custom Encoders](http://typelevel.github.io/frameless/docs/book/Injection.html) +* [Using Cats with RDDs](http://typelevel.github.io/frameless/docs/book/Cats.html) +* [Proof of Concept: TypedDataFrame](http://typelevel.github.io/frameless/docs/book/TypedDataFrame.html) + +## Why? + +Benefits of using `TypedDataset` compared to the standard Spark `Dataset` API: + +* Typesafe columns referencing and expressions +* Customizable, typesafe encoders +* Typesafe casting and projections +* Enhanced type signature for some built-in functions + +## Quick Start +Frameless is compiled against Scala 2.11.x. + +Note that while Frameless is still getting off the ground, it is very possible that breaking changes will be +made for at least the next few versions. + +To use Frameless in your project add the following in your `build.sbt` file as needed: + +```scala +resolvers += Resolver.sonatypeRepo("releases") + +val framelessVersion = "0.3.0" + +libraryDependencies ++= List( + "org.typelevel" %% "frameless-cats" % framelessVersion, + "org.typelevel" %% "frameless-dataset" % framelessVersion +) +``` + +An easy way to bootstrap a Frameless sbt project: + +- if you have [Giter8][g8] installed then simply: + +```bash +g8 imarios/frameless.g8 +``` +- with sbt >= 0.13.13: + +```bash +sbt new imarios/frameless.g8 +``` +Typing `sbt console` inside your project will bring up a shell with Frameless +and all its dependencies loaded (including Spark). + +## Development +We require at least *one* sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers +(people who can merge pull requests) are: + +* [adelbertc](https://github.com/adelbertc) +* [imarios](https://github.com/imarios) +* [jeremyrsmith](https://github.com/jeremyrsmith) +* [kanterov](https://github.com/kanterov) +* [non](https://github.com/non) +* [OlivierBlanvillain](https://github.com/OlivierBlanvillain/) + +## License +Code is provided under the Apache 2.0 license available at http://opensource.org/licenses/Apache-2.0, +as well as in the LICENSE file. This is the same license used as Spark. + +[g8]: http://www.foundweekends.org/giter8/ From 0963f2c81e66f8eff8f65e627462b32b781b0a9e Mon Sep 17 00:00:00 2001 From: Olivier Blanvillain Date: Tue, 23 May 2017 10:59:43 +0200 Subject: [PATCH 002/220] Rebuild documentation (eefecb5) --- docs/book/Cats.html => Cats.html | 2 +- .../FeatureOverview.html => FeatureOverview.html | 2 +- docs/book/Injection.html => Injection.html | 10 +++++----- docs/book/Job.html => Job.html | 6 +++--- .../TypedDataFrame.html => TypedDataFrame.html | 2 +- ...taset.html => TypedDatasetVsSparkDataset.html | 4 ++-- docs/book/TypedEncoder.html => TypedEncoder.html | 4 ++-- docs/book/search_index.json | 1 - docs/src/main/tut/README.md | 13 +++++++------ .../fonts/fontawesome/FontAwesome.otf | Bin .../fonts/fontawesome/fontawesome-webfont.eot | Bin .../fonts/fontawesome/fontawesome-webfont.svg | 0 .../fonts/fontawesome/fontawesome-webfont.ttf | Bin .../fonts/fontawesome/fontawesome-webfont.woff | Bin .../fonts/fontawesome/fontawesome-webfont.woff2 | Bin .../gitbook-plugin-fontsettings/fontsettings.js | 0 .../gitbook-plugin-fontsettings/website.css | 0 .../gitbook-plugin-highlight/ebook.css | 0 .../gitbook-plugin-highlight/website.css | 0 .../gitbook-plugin-lunr/lunr.min.js | 0 .../gitbook-plugin-lunr/search-lunr.js | 0 .../gitbook-plugin-search/lunr.min.js | 0 .../gitbook-plugin-search/search-engine.js | 0 .../gitbook-plugin-search/search.css | 0 .../gitbook-plugin-search/search.js | 0 .../gitbook-plugin-sharing/buttons.js | 0 {docs/book/gitbook => gitbook}/gitbook.js | 0 .../images/apple-touch-icon-precomposed-152.png | Bin .../book/gitbook => gitbook}/images/favicon.ico | Bin {docs/book/gitbook => gitbook}/style.css | 0 {docs/book/gitbook => gitbook}/theme.js | 0 docs/book/index.html => index.html | 15 ++++++++------- search_index.json | 1 + 33 files changed, 31 insertions(+), 29 deletions(-) rename docs/book/Cats.html => Cats.html (99%) rename docs/book/FeatureOverview.html => FeatureOverview.html (99%) rename docs/book/Injection.html => Injection.html (97%) rename docs/book/Job.html => Job.html (97%) rename docs/book/TypedDataFrame.html => TypedDataFrame.html (99%) rename docs/book/TypedDatasetVsSparkDataset.html => TypedDatasetVsSparkDataset.html (99%) rename docs/book/TypedEncoder.html => TypedEncoder.html (99%) delete mode 100644 docs/book/search_index.json rename {docs/book/gitbook => gitbook}/fonts/fontawesome/FontAwesome.otf (100%) rename {docs/book/gitbook => gitbook}/fonts/fontawesome/fontawesome-webfont.eot (100%) rename {docs/book/gitbook => gitbook}/fonts/fontawesome/fontawesome-webfont.svg (100%) rename {docs/book/gitbook => gitbook}/fonts/fontawesome/fontawesome-webfont.ttf (100%) rename {docs/book/gitbook => gitbook}/fonts/fontawesome/fontawesome-webfont.woff (100%) rename {docs/book/gitbook => gitbook}/fonts/fontawesome/fontawesome-webfont.woff2 (100%) rename {docs/book/gitbook => gitbook}/gitbook-plugin-fontsettings/fontsettings.js (100%) rename {docs/book/gitbook => gitbook}/gitbook-plugin-fontsettings/website.css (100%) rename {docs/book/gitbook => gitbook}/gitbook-plugin-highlight/ebook.css (100%) rename {docs/book/gitbook => gitbook}/gitbook-plugin-highlight/website.css (100%) rename {docs/book/gitbook => gitbook}/gitbook-plugin-lunr/lunr.min.js (100%) rename {docs/book/gitbook => gitbook}/gitbook-plugin-lunr/search-lunr.js (100%) rename {docs/book/gitbook => gitbook}/gitbook-plugin-search/lunr.min.js (100%) rename {docs/book/gitbook => gitbook}/gitbook-plugin-search/search-engine.js (100%) rename {docs/book/gitbook => gitbook}/gitbook-plugin-search/search.css (100%) rename {docs/book/gitbook => gitbook}/gitbook-plugin-search/search.js (100%) rename {docs/book/gitbook => gitbook}/gitbook-plugin-sharing/buttons.js (100%) rename {docs/book/gitbook => gitbook}/gitbook.js (100%) rename {docs/book/gitbook => gitbook}/images/apple-touch-icon-precomposed-152.png (100%) rename {docs/book/gitbook => gitbook}/images/favicon.ico (100%) rename {docs/book/gitbook => gitbook}/style.css (100%) rename {docs/book/gitbook => gitbook}/theme.js (100%) rename docs/book/index.html => index.html (93%) create mode 100644 search_index.json diff --git a/docs/book/Cats.html b/Cats.html similarity index 99% rename from docs/book/Cats.html rename to Cats.html index 75301856d..55d1b5f14 100644 --- a/docs/book/Cats.html +++ b/Cats.html @@ -366,7 +366,7 @@

                No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"next":{"title":"Proof of Concept: TypedDataFrame","level":"1.8","depth":1,"path":"TypedDataFrame.md","ref":"TypedDataFrame.md","articles":[]},"previous":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Cats.md","mtime":"2017-05-22T07:53:29.666Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-22T07:54:13.738Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"next":{"title":"Proof of Concept: TypedDataFrame","level":"1.8","depth":1,"path":"TypedDataFrame.md","ref":"TypedDataFrame.md","articles":[]},"previous":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Cats.md","mtime":"2017-05-23T08:57:27.070Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-23T08:59:39.758Z"},"basePath":".","book":{"language":""}}); }); diff --git a/docs/book/FeatureOverview.html b/FeatureOverview.html similarity index 99% rename from docs/book/FeatureOverview.html rename to FeatureOverview.html index 661bee470..1399710c2 100644 --- a/docs/book/FeatureOverview.html +++ b/FeatureOverview.html @@ -678,7 +678,7 @@

                No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"next":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"previous":{"title":"Introduction","level":"1.1","depth":1,"path":"README.md","ref":"README.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"FeatureOverview.md","mtime":"2017-05-22T07:54:08.818Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-22T07:54:13.738Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"next":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"previous":{"title":"Introduction","level":"1.1","depth":1,"path":"README.md","ref":"README.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"FeatureOverview.md","mtime":"2017-05-23T08:58:06.851Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-23T08:59:39.758Z"},"basePath":".","book":{"language":""}}); }); diff --git a/docs/book/Injection.html b/Injection.html similarity index 97% rename from docs/book/Injection.html rename to Injection.html index 428910d88..6ac336957 100644 --- a/docs/book/Injection.html +++ b/Injection.html @@ -252,7 +252,7 @@

                Example

                // defined class Person val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42,Mon May 22 09:53:10 CEST 2017)) +// people: Seq[Person] = List(Person(42,Tue May 23 10:57:10 CEST 2017))

                And an instance of a TypedDataset:

                val personDS = TypedDataset.create(people)
@@ -269,14 +269,14 @@ 
                Example
                
   def apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@6cd5eaec
+// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@6d6cc4bc

                We can be less verbose using the Injection.apply function:

                import frameless._
 // import frameless._
 
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@7a09999d
+// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@79ea3da5

                Now we can create our TypedDataset:

                val personDS = TypedDataset.create(people)
@@ -321,7 +321,7 @@ 
                Another example
                
     case 2 => Female
     case 3 => Other
   })
-// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@2ac4b462
+// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@70fdc07e

                And now we can create our TypedDataset:

                val personDS = TypedDataset.create(people)
@@ -370,7 +370,7 @@ 
                No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"next":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"previous":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Injection.md","mtime":"2017-05-22T07:53:17.890Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-22T07:54:13.738Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"next":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"previous":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Injection.md","mtime":"2017-05-23T08:57:16.378Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-23T08:59:39.758Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/docs/book/Job.html b/Job.html
similarity index 97%
rename from docs/book/Job.html
rename to Job.html
index 54e353fec..cca8a51be 100644
--- a/docs/book/Job.html
+++ b/Job.html
@@ -261,7 +261,7 @@ 
                Job[A]
                
     count <- ds.count()
     sample <- ds.take((count/5).toInt)
   } yield sample
-// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@58cb898
+// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@1052ec89
 
 countAndTakeJob.run()
 // res1: Seq[Int] = WrappedArray(1, 2, 3, 4)
@@ -276,7 +276,7 @@ 
                Job[A]
                
 // computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]
 
 val finalJob = computeMinOfSample(countAndTakeJob)
-// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@7b8ecc47
+// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@2e359e76

                Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, @@ -330,7 +330,7 @@

                No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"Job[A]","level":"1.6","depth":1,"next":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"path":"Cats.md","ref":"Cats.md","articles":[]},"previous":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"path":"Injection.md","ref":"Injection.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Job.md","mtime":"2017-05-22T07:53:33.458Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-22T07:54:13.738Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"Job[A]","level":"1.6","depth":1,"next":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"path":"Cats.md","ref":"Cats.md","articles":[]},"previous":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"path":"Injection.md","ref":"Injection.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Job.md","mtime":"2017-05-23T08:57:31.174Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-23T08:59:39.758Z"},"basePath":".","book":{"language":""}}); }); diff --git a/docs/book/TypedDataFrame.html b/TypedDataFrame.html similarity index 99% rename from docs/book/TypedDataFrame.html rename to TypedDataFrame.html index f3f5762ed..6246b06e5 100644 --- a/docs/book/TypedDataFrame.html +++ b/TypedDataFrame.html @@ -378,7 +378,7 @@

                No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"Proof of Concept: TypedDataFrame","level":"1.8","depth":1,"previous":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"path":"Cats.md","ref":"Cats.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedDataFrame.md","mtime":"2017-05-22T07:54:09.562Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-22T07:54:13.738Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"Proof of Concept: TypedDataFrame","level":"1.8","depth":1,"previous":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"path":"Cats.md","ref":"Cats.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedDataFrame.md","mtime":"2017-05-23T08:58:07.647Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-23T08:59:39.758Z"},"basePath":".","book":{"language":""}}); }); diff --git a/docs/book/TypedDatasetVsSparkDataset.html b/TypedDatasetVsSparkDataset.html similarity index 99% rename from docs/book/TypedDatasetVsSparkDataset.html rename to TypedDatasetVsSparkDataset.html index 1ae81e091..8a2d87470 100644 --- a/docs/book/TypedDatasetVsSparkDataset.html +++ b/TypedDatasetVsSparkDataset.html @@ -270,9 +270,9 @@

                Comparing TypedDatasets wi // +---+---+ // | i| j| // +---+---+ -// | 10| W| // |100| E| // | 1| Q| +// | 10| W| // +---+---+ // @@ -493,7 +493,7 @@

                No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"next":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"previous":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"path":"FeatureOverview.md","ref":"FeatureOverview.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedDatasetVsSparkDataset.md","mtime":"2017-05-22T07:53:48.562Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-22T07:54:13.738Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"next":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"previous":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"path":"FeatureOverview.md","ref":"FeatureOverview.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedDatasetVsSparkDataset.md","mtime":"2017-05-23T08:57:44.854Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-23T08:59:39.758Z"},"basePath":".","book":{"language":""}}); }); diff --git a/docs/book/TypedEncoder.html b/TypedEncoder.html similarity index 99% rename from docs/book/TypedEncoder.html rename to TypedEncoder.html index e18711db8..8771da96d 100644 --- a/docs/book/TypedEncoder.html +++ b/TypedEncoder.html @@ -284,7 +284,7 @@

                Typed Encoders in Frameless

                // ds: frameless.TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@4e32dea0 +// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@8a0bd3c

                But any non-encodable in the case class hierarchy will be detected at compile time:

                case class BarDate(d: Double, s: String, t: java.util.Date)
@@ -339,7 +339,7 @@ 
                No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"next":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"path":"Injection.md","ref":"Injection.md","articles":[]},"previous":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedEncoder.md","mtime":"2017-05-22T07:53:39.894Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-22T07:54:13.738Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"next":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"path":"Injection.md","ref":"Injection.md","articles":[]},"previous":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedEncoder.md","mtime":"2017-05-23T08:57:36.410Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-23T08:59:39.758Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/docs/book/search_index.json b/docs/book/search_index.json
deleted file mode 100644
index 404f24e5a..000000000
--- a/docs/book/search_index.json
+++ /dev/null
@@ -1 +0,0 @@
-{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["\"0.3.0\"","\"frameless","\"org.typelevel\"","%","%%","(e.g.","(includ","(peopl","(support","(thumb",")","++=","+1,","+=","0.13.13:","0.9.x)","2.0","2.0,","2.0.x)","2.11.x.","=",">=","add","adelbertc","against","apach","api:","are:","associ","avail","benefit","bootstrap","break","bring","build.sbt","built","cast","cat","cats\"","chang","channel","code","column","compar","compil","concept","concept:","conduct","consist","consol","contribut","contributor","creat","current","custom","customizable,","dataset","dataset\"","depend","develop","document","easi","encod","enhanc","environ","express","featur","few","file","file.","follow","frameless","framelessvers","framelessversion,","friendli","function","g8","get","giter8","github,","gitter)","ground,","http://opensource.org/licenses/apach","imario","imarios/frameless.g8","injection:","insid","instal","introduct","jeremyrsmith","kanterov","learning.","librari","librarydepend","licens","list(","load","made","maintain","merg","modules:","more","needed:","new","next","non","note","olivierblanvillain","on","overview","possibl","project","project:","proof","provid","pull","quick","rdd","referenc","requests)","requests.","requir","resolv","resolver.sonatyperepo(\"releases\")","safe","same","sbt","scala","shell","sign","signatur","similar)","simply:","spark","spark'","spark).","spark.","standard","start","still","strongli","support","type","typeddatafram","typeddataset","typeddataset:","typelevel","types.","typesaf","under","up","up,","us","val","veri","versions.","want","way","well","why?","work"],"FeatureOverview.html":["\"false\")","\"paris\")","'`citi`'","'import","'name),","'population)","'price),","'project","(a)","(automated)","(b)","(enjoy","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(in","(lyon,166500.0))","(manual)","(name:","(paris,333333.3333333333),","(string,","(u:","(up","(which","(with",")",").as[aptpricecity].show().run",").as[stats].show().run()","*","+","...","/","//","1","10,","100,","10000.0,","102|","133000.0),","2","2).as[updatedsurface]","2).show().run()","2.0","200000.0),","2229621),","2229621|","2409.6385542168673,","25,","250000.0),","250|","25|[paris,","27|","2955.5555555555557,","300000.0),","325000.0)","343629)","343629|","4391.891891891892)","4391.891891891892|","45,","4500.0,","450000.0),","450|","458","47|","50,","500715),","500715|","500|","52|","6833.333333333333|","74,","740|","76|","83,","830|","85|",":27:",":28:",":31:",":33:",":34:",":36:","=","==","=>","['citi]","[1...10]).","[_1:","[city#206,","[city,","[city:","[lyon,45,133000.0]|","[lyon,500715]|","[lyon,83,200000.0]|","[nice,343629]|","[nice,74,325000.0]|","[paris,25,250000.0]|[paris,2229621]|","[paris,50,300000.0]|[paris,2229621]|","[ratio:","^","_1|","_2:","_2|","abov","achiev","actual","ad","addit","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","agg()","aggreg","aggregated,","agree.","align.","allcities:","allcities|","allow","allowed,","allowed.","alternatives:","and/or","anoth","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartmentdetail","apartmentdetails(city:","apartmentdetails?","api","appear","appli","aptd","aptds('price)","aptds('price)))","aptds('price),","aptds('surface))","aptds('surface)).as[apartmentdetails]","aptds('surface),","aptds.agg(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)).as[updatedsurface]","apttypedds('city),","apttypedds('city).cast[double]","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.join(citiinfotypedds,","apttypedds.makeudf(pricemodifier)","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds2","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","arguments)","as:","as[t]","avail","available.","averag","averageable:","avg(aptds('price)),","avg(aptds('surface)),","avgprice:","avgprice|","avgsurface:","avgsurface|minsurface|","base","better","between","boolean","boolean)].","c:","calcul","can't","case","case.","cast","cast,","catalystcast.","catalystcast[string,","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name))","city:","cityinfo","cityinfo(city:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|surface|","class","class:","claus","clause.","code","collectset(aptds('city))","column","column:","columns:","combin","compil","compile.","compile:","compiles:","complet","comput","computations.","conf","context","continu","correspond","creat","dataset","dataset.","dataset:","defin","detail","directli","discuss","divid","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","each","easili","elid","enabl","enabled.","entir","error","error.","error:","evid","exampl","example,","example.","exist","explan","explicitli","express","extra","featur","few","field","field]","fields]","find","five","follow","form","frameless","frameless.catalystaverageable[string,out]","frameless.catalystcast[string,double]","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.functions.aggregate._","frameless.implicits.widen._","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[apartment,double])(implicit","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","function","gener","get","give","given","groupbi","groupby()","here","here.","here:","however,","id","if(nam","implicit","implicitli","import","inform","initi","input","instanc","instances:","instanti","int","int)","int).","int,","int.","int]","interest","introduc","job","join","language:postfixops.","lazi","lazy.","let'","lift","localrel","long","look","lyon]|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","macro","make","materialize.","math","matter","member","method","method.","min(aptds('surface)),","minimum","minsurface:","misspel","mistak","more","n","n:","name","name:","need","new","next","next,","nice,","nice|","nice|325000.0|","not,","note","now","on","oper","operations:","option","order","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:58)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:77)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$8.apply(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2$1.apply(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionup$1(queryplan.scala:269)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:69)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:308)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:126)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:186)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:307)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:64)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2603)","org.apache.spark.sql.dataset.select(dataset.scala:969)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:49)","org.apache.spark.sql.sparksess","org.apache.spark.{sparkconf,","overload","overview","paramet","particular","per","perform","perhap","popul","population:","postfix","prefer","preserv","price","price#208]","price,","price/surfac","price:","price:double)","price];;","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.collect.run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","proce","project","prove","rais","ratio","ratio:","ratio|","readi","referenc","repl\").set(\"spark.ui.enabled\",","requir","res17:","res6:","res7:","resolv","result","retriev","right?","row","run","run()","safe","safe,","safe.","safety,","safety.","same","scala","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala.language.postfixop","scala.language.postfixops'","scaladoc","see","seem","select","select()","selectmany()","selectmany,","seq(","seq[(string,","seq[double]","set","shapeless.tag.tagged[string(\"citi\")]","shorter","show","show()","simpl","skip","spark","spark.createdataset(apartments)","spark.implicits._","spark.sparkcontext.setloglevel(\"warn\")","spark.sqlcontext","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","sqlcontext","stack","standard","start","stat","stats(","string","string)","string),updatedsurface]","string,","string]","struct,","struct]","subset","suggests,","support","suppos","surfac","surface#207,","surface,","surface,th","surface:","symbol","syntax:","t","tell","ten","three","time","time,","top","trace):","tri","tutori","two","type","type:","typedcolumn","typeddataset","typeddataset.","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","types,","typesaf","typo","u","udf","udf(aptds('city),","udf:","unit:","unlik","unsaf","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","val","valid","valu","vector[string])","visible.","want","warning:","way","wherea","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","work","worked,","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","|","|1000|102|","|276333.3333333333|62.833333333333336|","|4500.0|450000.0|","|6000.0|300000.0|","|[paris,100,450000.0]|[paris,2229621]|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|"],"TypedDatasetVsSparkDataset.html":["\"e\")","\"java.util.date\",","\"jday\")","\"mydate\"","\"q\")","\"w\")","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","&&","'`x`'","'project","(case","(class:","(i#69l","(int,","(isnotnull(i#69l)","(look","(see","(the",")",").explain()",").select(",").show().run()","*batchedscan","*deserializetoobject","*filter","*mapel","*project","*serializefromobject","+",",","...",".appli","//","10","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10|","1|","450","770",":20:",":21:",":22:","::","=","==","===","['x]","[],","[i#69l","[i#69l,j#70]","[i#69l]","[i,","[i:","[input[0,","[isnotnull(i),","^","_1#176l]","_1|","above.","access","achiev","act","ad","allow","api","applications.","area","argument","as[long]","assum","at[long]","avoid","bar","bar(1)))","bar(i:","before.","bigint","bigint))","bigint,","bigint]","bind","both","bug","bulletproof:","captur","case","cast","cast(10","catalyst","class","class:","classes)","clearli","closur","closures.","code","code.","column","columnar","columns,","columns:","compar","comparison,","compil","compromis","content","context","correct.","correctli","creat","current","dataset","dataset.","dataset[long].","datasets,","defin","detail.","detect","differ","discuss","discussion.","disk","doesn't","ds","ds.filter($\"i\"","ds.filter(_.i","ds.show()","ds:","each","elid","encod","encoder:","entir","equalto(i,10)],","error","error:","etc)","exampl","example,","exist","explain","explicitli","express","extrem","e|","fail","failure:","familiar","fd","fds('i)","fds('x)","fds.filter(","fds:","few","field","fields.","file","file.","file:/tmp/foo,","filter","filteredd","filteredds.explain()","filteredds.show()","filteredds:","find","first","first,","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo,","foo.","format","format:","found","frameless","frameless'","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[mydate]","friend.","fulli","function","futur","generated.","give","given","goal:","great!","guard","handhold","help","here","here.","hold","however,","implement","implicit","import","improv","incompat","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","input","inputpaths:","insid","int)","introduc","intuitively,","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date(system.currenttimemillis))))","java.util.date)","j|","know","last","lead","let'","limit","line","linux","load","long","long,","look","mac","map","member","members.","mention","mistak","more","mydat","mydate(jday:","name","name:","need","newinstance(class","next","nil","non","note","notifi","now,","obj#103:","obj#104:","ok","on","oper","optim","optimizer)","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:58)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:77)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:61)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$8.apply(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2$1.apply(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionup$1(queryplan.scala:269)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:592)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:598)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:425)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:69)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:308)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:126)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:186)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:307)","org.apache.spark.sql.dataset.(dataset.scala:161)","org.apache.spark.sql.dataset.(dataset.scala:167)","org.apache.spark.sql.dataset.select(dataset.scala:1023)","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:274)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:49)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:47)","os","paramet","parquet","parquetformat,","partial","partitionfilters:","pass","performance.","physic","plan","plan,","plan.","plan:","popular","practic","primit","problem","problem.","product","product,","provid","pushedfilters:","queri","quick","q|","read","readschema).","readschema:","refer","relation[i#69l,j#70]","releases.","remind","requir","resolv","return","root","run","runtim","safe","safe.","safety!","safety.","save","scala","scala.","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala>","schema","second,","see","select","select()","separately,","serial","serv","set","shapeless.tag.tagged[string(\"x\")]","show","simpl","simplist","slow","small","solut","solv","spark","spark'","spark.","spark.createdataset(","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark:","sparksess","standard","statement","statement).","store","string)","string,","string]","struct","subset","suffici","support","symbol","syntax","syntax.","take","thing","this.","time","time.","time:","togeth","tri","true]","tutori","two","type","type.","typedcolumn","typeddataset","typeddataset.","typeddataset.create(ds)","typeddataset.create(seq(mydate(new","typeddatset","unabl","unfortunately,","us","val","valu","value#105l]","veri","view","want","way","well","without","work","w|","x","x:","|","|100|","|value|"],"TypedEncoder.html":["\"daterange\"","\"java.util.date\",","\"s\")","\"s\"))))","\"s\",","(a","(and","(class:","...","//","2.0)","230",":26:",":28:","=","[i:","^","annoy","approach","around","b:","bar","bar(1.1,","bar(d:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","behav","besid","call","case","class","class:","classes.","code","compil","construct","coupl","current","custom","data","data.","dataset","dataset?.","dataset[daterange]","daterange(s:","decod","defin","deriv","derived,","detect","different,","double,","ds.collect()","ds:","e:","elid","encod","encoder.","encoder:","encoders,","ensur","error","error:","exampl","example,","existence)","expected:","extend","fail","field","find","follow","foo","foo(i:","foodate(i:","found","frameless","frameless.job$$anon$4@4e32dea0","frameless.job[seq[foo]]","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless:","gener","goe","hierarchi","ident","implicit","implicitli","import","inabl","int,","intern","introduc","issues.","it'","java.lang.unsupportedoperationexception:","java.util.d","java.util.date)","java.util.date)))","java.util.date))))","java.util.date,","jvm","lead","limit","manipul","mechan","method","more","name:","new","non","note","object","onc","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:61)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:592)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:598)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:425)","org.apache.spark.sql.dataset","org.apache.spark.sql.encoders$.product(encoders.scala:274)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:47)","overflow","paramet","pass","performances.","prove","question","recurs","reflect","represent","res2:","resolut","root","run","runtim","s:","same","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala>","scalareflect","schema.","see","shapeless","shown","situat","solv","spark","spark.implicits._","spark:","sqlcontext.createdataset(seq(daterange(new","stack","standard","store","string)","string,","struct]","summari","support","t:","take","thought","time,","time.","time:","trace,","tri","type","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeencod","types.","us","val","valu","vanilla","won't","work"],"Injection.html":["$anon$1@6cd5eaec","//","09:53:10","1","2","2017))","22","3",":24:",":32:","=","=>","[age:","^","a):","again","anoth","apply(a:","apply(d:","available,","b","b):","b.","b]","bigint]","birthday:","can't,","case","cest","class","class:","compil","creat","custom","d.gettime()","datetolonginject","datetolonginjection:","def","defin","definit","encod","encoder:","error.","error:","exampl","extend","family:","femal","find","frameless._","frameless.injection$$anon$1@2ac4b462","frameless.injection$$anon$1@7a09999d","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.typeddataset[person]","frameless.typedencoder[person]","function:","gender","gender)","gender:","gendertoint:","implicit","import","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","instanc","int,","int]","invert(b:","invert(l:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date)","java.util.date))","java.util.date).gettime(),","java.util.date):","java.util.date.","less","let","let'","list(person(42,male))","list(person(42,mon","long","long)))","long):","long:","long]","look","male","male))","more","new","now","object","on","paramet","peopl","people:","person","person(age:","persond","personds:","precis","seal","seq(person(42,","seq[person]","serializ","simpl","trait","tri","type","type,","typeclass:","typeddataset,","typeddataset.create(people)","typeddataset:","typedencod","us","val","valu","verbos","{","}","})","},"],"Job.html":["(a","(sample:","//","1","20%","20)","=","[_1:","above)","allow","along","annotate/nam","applic","be","block","calcul","collect","compar","complex","compos","composit","comprehens","comput","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","count","countandtakejob","def","description.","differ","driver","ds","ds:","easier","element","elements:","exactli","exampl","execut","expens","explicit","explicitli","few","finaljob","finaljob.","finaljob:","first","frameless.job","frameless.job$$anon$2@7b8ecc47","frameless.job[int]","frameless.job[seq[int]])frameless.job[int]","frameless.typeddataset[int]","functions:","further","group","have","help","id","import","inform","int","int]","issues.","job","job[a]","job[a],","job[int]","job[seq[int]]):","jobs.","lazi","lazili","lazy,","lazy.","make","min\").","monad","more","new","non","now","obviou","oper","part","pass","perform","place","predict","program","programm","provid","res2:","result","return","run","run()","sample.map(_.min)","say,","see","sequenc","serv","sever","show","showcas","size","spark","spark.","specifi","strict","toy","track","track,","transform","typeddataset","typeddataset.create(1","ui","us","val","via","withdescription(\"sampl","withgroupid(\"samplingjob\").","{"],"Cats.html":["\"task2\"","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(1,","(1,2,3)","(10,9,9)","(8,","(8,2,3)","(and","(chris,map(0","(john,map(0","(sam,map(0","(semigroup)",")","//","1","1)","1))","1)),","1),","1,","10))","10,","100)","11))","12)","12,","15)))","2","2)","2))","2)),","2,","20)","20,","3)","3))","3,","32,","4))","4)),","4,","5,","6,",":21",":22",":24",":26","::","=",">","aggreg","alia","alias","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","anna","arbitrari","arity.","array((joe,map(0","array[(username,","assum","avg,","below","cat","cats.implicits.","cats.implicits._","cats:","class","collect","column","combin","common","complex","comput","data","data.","data:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","default","defin","differ","element","etc.","exampl","example,","example:","execut","follow","frameless.cats.implicits._","frameless.cats.outer._","full","general).","group","implicit","implicits.scala:18","implicits.scala:43","import","int","int)]","int,","joe","join","key","key.","keys.","larg","leverag","makerdd","map(\"task1\"","map(\"task3\"","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[10]","mapvalu","max,","meaning","min,","more","nil","nil)","note","offer","on","oper","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","outer","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","pair","parallelcollectionrdd[0]","parallelcollectionrdd[1]","parallelcollectionrdd[3]","parallelcollectionrdd[5]","parallelcollectionrdd[6]","predicates.","previous","println(data.cmax)","println(data.cmin)","println(data.csum)","rdd","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","reducebykey","res10:","res11:","res7:","res8:","same","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala.collection.immutable.map[string,int])]","scala.collection.map[string,scala.collection.immutable.map[string,int]]","scala.collection.map[user,transactioncount]","section","semigroup","set","show","shuffledrdd[2]","shuffledrdd[4]","simplifi","sort","spark","string","task","task2","task3","timeseri","timeseries)]","together.","totalperus","totalperuser.collectasmap","totalperuser:","transactioncount","transactioncount)]","tupl","type","type.","us","user","user'","usernam","val","valu","way","work","|+|"],"TypedDataFrame.html":["\"dummy\"","\"unique\"","').map(r","'_4)","'q',","'s)","'x',","'z'))","'z'.","(((((((((","(implicit","(phonebooktf:",")",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","//","1.6","1.6+,","1.6,","11","2.10,","2.11","2.11,","22.",":",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","=>","???","addit","address","address,","address:","alphabet:","alternatively,","amount","api","approach","approxim","ariti","avail","away:","b:","bar(i:","be","bestneighborhood","boolean","boolean)","boolean):","boolean)]","boolean,","both","bring","c:","call","case","catch","caus","citi","citymapentry(","citymaptf:","class","column","columns.","come","common","commonli","compar","compat","compil","complet","comput","concept:","consid","consist","contain","conveni","correct","cough","count:","d:","data,","datafram","dataframe,","dataframes,","dataset","def","defin","definit","deprec","design","develop","differ","directli","dive","documented.","domain","done","doubl","double,","due","each","earli","element","enough","ensur","essenti","everyth","exampl","example:","except","execut","exist","expect","f","f.neighborhood))","f.residents.split('","fact","family(residents:","field","filter(conditionexpr:","first","flat","focu","follow","foo(s:","frameless","frameless.","frameless.typeddatafram","frameless:","function","further","futur","get","go","goal","goe","handl","have","here","hold","however,","i:","ident","import","improv","inform","instead","int)","int,","interest","intermedi","introduc","introduct","j:","job","jobs.","join","join1(tf1:","join2(tf1:","joins,","keep","languag","less","let","let'","letter","level","leverag","librari","like,","limit","limitations.","line","long)","long)])","look","main","manag","manipul","manner.","map","mirror","mistak","model","moder","more","much","name","name.exists(set('x',","names,","natur","need","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","nlplib","nlplib.uniquename(p.name)","now","number,","object","obtain","ontypeddataframe.","onward.","org.apache.spark.sql.datafram","org.apache.spark.sql.sqlcontext","p","packag","pair","person(name:","person(r,","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","point,","possibl","process","product.","proof","provid","public","readability.","readabl","reasons,","refer","referenc","represent","residents:","result","rethought","return","right","sadly,","safe","safety.","scala","schema","schema.","second","see","see,","seem","select","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","shadow","shapeless.hlist","signatures:","similar","simplifi","singl","spark","spark'","spark,","sqlcontext):","stage","still","store","string","string):","string)]","string)])","string,","suppos","syntax","syntaxes,","system","systems,","tabl","table,","tables:","target","tdataframe[schema","tdataframe[schema]","techniqu","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","time.","track","troubl","tuple23","two","type","type,","type.","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry]","typeddataframe[citymapentry])","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","types:","typo,","uniqu","uniquename(name:","us","user","valu","vanilla","variou","veri","version","way","well,","won't","work","zero.","{","}"]},"length":8},"tokenStore":{"root":{"0":{"9":{"docs":{},":":{"5":{"3":{"docs":{},":":{"1":{"0":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{},".":{"1":{"3":{"docs":{},".":{"1":{"3":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"docs":{}},"docs":{}}},"docs":{}},"9":{"docs":{},".":{"docs":{},"x":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}},"docs":{}}},"1":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"i":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.017391304347826087}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.013043478260869565}}},".":{"6":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"+":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"docs":{}}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"1":{"7":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"docs":{}},"docs":{},"%":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"3":{"0":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"docs":{}},"4":{"0":{"9":{"docs":{},".":{"6":{"3":{"8":{"5":{"5":{"4":{"2":{"1":{"6":{"8":{"6":{"7":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"9":{"5":{"5":{"docs":{},".":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},".":{"docs":{},"x":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"1":{"0":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{},"x":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"docs":{}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}}}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"4":{"3":{"6":{"2":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"4":{"3":{"9":{"1":{"docs":{},".":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"8":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"6":{"8":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"7":{"4":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"7":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"docs":{}},"docs":{}},"8":{"3":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{},"\"":{"0":{"docs":{},".":{"3":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"docs":{}}},"docs":{}}},"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"q":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"w":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"y":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"2":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"docs":{}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"%":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}},"%":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}}},"(":{"1":{"0":{"docs":{},",":{"9":{"docs":{},",":{"9":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}},"docs":{}}},"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"8":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"y":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}},"t":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"#":{"6":{"9":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}},"docs":{}},"docs":{}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"6":{"9":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}},"e":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"b":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"1":{"6":{"6":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"u":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}}}},"\"":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}}}}},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}}}}},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}}},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}},"+":{"1":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0622906898861353},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.04267589388696655}},"+":{"docs":{},"=":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"=":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"=":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.03415941058271936},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01384083044982699},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.024922118380062305},"Injection.html":{"ref":"Injection.html","tf":0.06349206349206349},"Job.html":{"ref":"Job.html","tf":0.040229885057471264},"Cats.html":{"ref":"Cats.html","tf":0.05217391304347826},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.016605166051660517}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.011534025374855825}},"=":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495}}}},">":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}},">":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.08695652173913043}},"=":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"e":{"docs":{},"l":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"d":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}},"s":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"3":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"(":{"docs":{},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"[":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},"e":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"b":{"docs":{},"o":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Job.html":{"ref":"Job.html","tf":0.017241379310344827}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"n":{"docs":{},"o":{"docs":{},"y":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"t":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"b":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"docs":{}}},"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"(":{"1":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"docs":{}},"docs":{}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007367716008037508},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.024922118380062305},"Injection.html":{"ref":"Injection.html","tf":0.04126984126984127},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01845018450184502}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.018691588785046728},"Cats.html":{"ref":"Cats.html","tf":3.339855072463768}},"s":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"u":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012915129151291513}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.502306805074971},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"x":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}}}}}},"o":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351783517835174}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"o":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Injection.html":{"ref":"Injection.html","tf":2.5126984126984127}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":2.503174603174603}},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.010716677829872739},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010380622837370242},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03426791277258567},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.02214022140221402}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"u":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.018691588785046728},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5092272202998847},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"\"":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"?":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012915129151291513}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}}}}}}}}},"y":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"f":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014760147601476014}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.03492063492063492},"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018691588785046728}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"e":{"docs":{},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"_":{"docs":{},".":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.021806853582554516},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"u":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.014018691588785047},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3551401869158877},"Injection.html":{"ref":"Injection.html","tf":2.5126984126984127}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"s":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"t":{"docs":{},"i":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"s":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"i":{"docs":{},",":{"1":{"0":{"docs":{},")":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"docs":{}},"docs":{}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.334672918062067}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}},":":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}}},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},"a":{"docs":{},"l":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"c":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.04205607476635514},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3426791277258565},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}}}}}}}}}}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"2":{"docs":{},"a":{"docs":{},"c":{"4":{"docs":{},"b":{"4":{"6":{"2":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}},"7":{"docs":{},"a":{"0":{"9":{"9":{"9":{"9":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"2":{"docs":{},"@":{"7":{"docs":{},"b":{"8":{"docs":{},"e":{"docs":{},"c":{"docs":{},"c":{"4":{"7":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"docs":{}},"docs":{}}}}},"docs":{}}},"docs":{}}},"4":{"docs":{},"@":{"4":{"docs":{},"e":{"3":{"2":{"docs":{},"d":{"docs":{},"e":{"docs":{},"a":{"0":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"docs":{}}}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"_":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}}}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"s":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495}}}},"x":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"l":{"docs":{},")":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015873015873015872}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}}},"t":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"8":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},"docs":{}}},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"p":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"b":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}},"o":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"a":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"l":{"docs":{},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"v":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"s":{"docs":{},"/":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}},"docs":{}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152},"Injection.html":{"ref":"Injection.html","tf":0.015873015873015872},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"docs":{}},"4":{"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}},"docs":{}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008707300736771601},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.017391304347826087},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015873015873015872}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"Injection.html":{"ref":"Injection.html","tf":2.503174603174603}}},"(":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},"n":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"t":{"docs":{"./":{"ref":"./","tf":10},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"l":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"f":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"t":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"j":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"y":{"docs":{},"r":{"docs":{},"s":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.022988505747126436},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":10.005747126436782}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"n":{"1":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}}}}},"2":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01107011070110701}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"l":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.01557632398753894}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"v":{"docs":{},"m":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"e":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"s":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}}}}},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.018691588785046728}}}}}},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"o":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"docs":{}},"docs":{}}}}}}}}}}},"f":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"u":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"o":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},":":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"y":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"r":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"8":{"2":{"docs":{},".":{"5":{"9":{"7":{"0":{"5":{"4":{"8":{"8":{"6":{"2":{"1":{"1":{"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"m":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"r":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"Job.html":{"ref":"Job.html","tf":0.022988505747126436}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.013043478260869565}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}},"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}},"3":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"docs":{}}}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"0":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"n":{"docs":{},"i":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"e":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"x":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"e":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007367716008037508},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"a":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"u":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"e":{"docs":{},"(":{"docs":{},"j":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018691588785046728},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}},"x":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"t":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"v":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}}}}}}}}}}},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"c":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3340031256977003}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Job.html":{"ref":"Job.html","tf":0.028735632183908046},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00922722029988466}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"$":{"2":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"7":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"8":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"2":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"2":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"$":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"0":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"0":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"9":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"8":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"9":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"8":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"9":{"8":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"$":{"docs":{},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"$":{"docs":{},"$":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"0":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"2":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}},"9":{"6":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"6":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"$":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"{":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},".":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"j":{"docs":{},"#":{"1":{"0":{"3":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.018691588785046728},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"o":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351783517835174}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}},"#":{"2":{"0":{"8":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"/":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"b":{"docs":{},"y":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"3":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.009345794392523364}}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"1":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"3":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"5":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"6":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"i":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.012687427912341407}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"i":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"s":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}},"(":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905}},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"t":{"docs":{},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"c":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"Cats.html":{"ref":"Cats.html","tf":3.3376811594202898}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"i":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}},"s":{"1":{"0":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"1":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"2":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"8":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"a":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"u":{"docs":{},"i":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"#":{"6":{"9":{"docs":{},"l":{"docs":{},",":{"docs":{},"j":{"docs":{},"#":{"7":{"0":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}},"o":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"m":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"y":{"docs":{},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"d":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.018691588785046728}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"5":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"9":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"s":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},">":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"2":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"4":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"y":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"z":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.018691588785046728},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01384083044982699},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Job.html":{"ref":"Job.html","tf":0.034482758620689655},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01845018450184502}},"'":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5046136101499425},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},")":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"[":{"docs":{},"*":{"docs":{},"]":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"g":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},",":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.014735432016075016},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014760147601476014}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"#":{"2":{"0":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007367716008037508}}}}}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"[":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.017241379310344827}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"i":{"docs":{},"z":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.018691588785046728},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.010046885465505693},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0196078431372549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Cats.html":{"ref":"Cats.html","tf":0.02391304347826087},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.027675276752767528}},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.34440344403444}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"p":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.009345794392523364},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5034602076124566},"Job.html":{"ref":"Job.html","tf":0.022988505747126436}},":":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3353427104264344},"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"docs":{}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905}}}}}}}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"[":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}},"u":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"a":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.014018691588785047},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}}}},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"u":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"p":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"2":{"3":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"docs":{}},"docs":{}}}}},"w":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{},"k":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}},"f":{"1":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"j":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"2":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"j":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}},"i":{"docs":{},"t":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}}},"p":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}},",":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{"./":{"ref":"./","tf":0.028037383177570093},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"Job.html":{"ref":"Job.html","tf":0.017241379310344827},"Cats.html":{"ref":"Cats.html","tf":3.339855072463768},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.00922509225092251}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"'":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}},"d":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.018754186202277295},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018691588785046728},"Injection.html":{"ref":"Injection.html","tf":0.03492063492063492},"Job.html":{"ref":"Job.html","tf":0.017241379310344827},"Cats.html":{"ref":"Cats.html","tf":0.017391304347826087}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},"#":{"1":{"0":{"5":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"docs":{}},"docs":{}},"docs":{}}}}},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"a":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"y":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"h":{"docs":{},"y":{"docs":{},"?":{"docs":{"./":{"ref":"./","tf":0.004672897196261682}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.004672897196261682},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"(":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"'":{"docs":{},"`":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"x":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"_":{"4":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"q":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"z":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"*":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"b":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006028131279303416},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"_":{"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"docs":{}}}}}}},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.12391158740790355},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.08419838523644751},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.06666666666666667},"Job.html":{"ref":"Job.html","tf":0.028735632183908046},"Cats.html":{"ref":"Cats.html","tf":0.05},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},":":{"2":{"0":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"4":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"6":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"3":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"2":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"4":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Cats.html":{"ref":"Cats.html","tf":0.0391304347826087}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"[":{"1":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"1":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"docs":{}},"docs":{}}}}},"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"x":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"_":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"docs":{}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"#":{"2":{"0":{"6":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006697923643670462}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"4":{"5":{"docs":{},",":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"8":{"3":{"docs":{},",":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"4":{"3":{"6":{"2":{"9":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"7":{"4":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"5":{"docs":{},",":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"5":{"0":{"docs":{},",":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}},"i":{"docs":{},"#":{"6":{"9":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},",":{"docs":{},"j":{"docs":{},"#":{"7":{"0":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"[":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}}}}}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}},"^":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008037508372404554},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},"_":{"1":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"#":{"1":{"7":{"6":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"docs":{}},"docs":{}},"docs":{}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}},"docs":{}},"|":{"1":{"0":{"0":{"0":{"docs":{},"|":{"1":{"0":{"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"2":{"7":{"6":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"6":{"2":{"docs":{},".":{"8":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.01808439383791025},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00922722029988466}},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"1":{"0":{"0":{"docs":{},",":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"+":{"docs":{},"|":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}}},"$":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"1":{"4":{"docs":{},".":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"6":{"docs":{},"c":{"docs":{},"d":{"5":{"docs":{},"e":{"docs":{},"a":{"docs":{},"e":{"docs":{},"c":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"docs":{}}}},"docs":{}}},"docs":{}}}}}}},"&":{"docs":{},"&":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"{":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},"}":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"?":{"docs":{},"?":{"docs":{},"?":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"length":2210},"corpusTokens":["\"0.3.0\"","\"daterange\"","\"dummy\"","\"e\")","\"false\")","\"frameless","\"java.util.date\",","\"jday\")","\"mydate\"","\"org.typelevel\"","\"paris\")","\"q\")","\"s\")","\"s\"))))","\"s\",","\"task2\"","\"unique\"","\"w\")","$anon$1@6cd5eaec","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","%","%%","&&","').map(r","'_4)","'`citi`'","'`x`'","'import","'name),","'population)","'price),","'project","'q',","'s)","'x',","'z'))","'z'.","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(((((((((","(1,","(1,2,3)","(10,9,9)","(8,","(8,2,3)","(a","(a)","(and","(automated)","(b)","(case","(chris,map(0","(class:","(e.g.","(enjoy","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(i#69l","(implicit","(in","(includ","(int,","(isnotnull(i#69l)","(john,map(0","(look","(lyon,166500.0))","(manual)","(name:","(paris,333333.3333333333),","(peopl","(phonebooktf:","(sam,map(0","(sample:","(see","(semigroup)","(string,","(support","(the","(thumb","(u:","(up","(which","(with",")",").as[aptpricecity].show().run",").as[stats].show().run()",").explain()",").select(",").show().run()","*","*batchedscan","*deserializetoobject","*filter","*mapel","*project","*serializefromobject","+","++=","+1,","+=",",","...",".appli",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","/","//","0.13.13:","0.9.x)","09:53:10","1","1)","1))","1)),","1),","1,","1.6","1.6+,","1.6,","10","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10,","100)","100,","10000.0,","102|","10|","11","11))","12)","12,","133000.0),","15)))","1|","2","2)","2))","2)),","2).as[updatedsurface]","2).show().run()","2,","2.0","2.0)","2.0,","2.0.x)","2.10,","2.11","2.11,","2.11.x.","20%","20)","20,","200000.0),","2017))","22","22.","2229621),","2229621|","230","2409.6385542168673,","25,","250000.0),","250|","25|[paris,","27|","2955.5555555555557,","3","3)","3))","3,","300000.0),","32,","325000.0)","343629)","343629|","4))","4)),","4,","4391.891891891892)","4391.891891891892|","45,","450","4500.0,","450000.0),","450|","458","47|","5,","50,","500715),","500715|","500|","52|","6,","6833.333333333333|","74,","740|","76|","770","83,","830|","85|",":",":20:",":21",":21:",":22",":22:",":24",":24:",":26",":26:",":27:",":28:",":31:",":32:",":33:",":34:",":36:","::",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","==","===","=>",">",">=","???","['citi]","['x]","[1...10]).","[],","[_1:","[age:","[city#206,","[city,","[city:","[i#69l","[i#69l,j#70]","[i#69l]","[i,","[i:","[input[0,","[isnotnull(i),","[lyon,45,133000.0]|","[lyon,500715]|","[lyon,83,200000.0]|","[nice,343629]|","[nice,74,325000.0]|","[paris,25,250000.0]|[paris,2229621]|","[paris,50,300000.0]|[paris,2229621]|","[ratio:","^","_1#176l]","_1|","_2:","_2|","a):","abov","above)","above.","access","achiev","act","actual","ad","add","addit","address","address,","address:","adelbertc","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","against","agg()","aggreg","aggregated,","agree.","alia","alias","align.","allcities:","allcities|","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","allowed,","allowed.","along","alphabet:","alternatively,","alternatives:","amount","and/or","anna","annotate/nam","annoy","anoth","apach","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartmentdetail","apartmentdetails(city:","apartmentdetails?","api","api:","appear","appli","applic","applications.","apply(a:","apply(d:","approach","approxim","aptd","aptds('price)","aptds('price)))","aptds('price),","aptds('surface))","aptds('surface)).as[apartmentdetails]","aptds('surface),","aptds.agg(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)).as[updatedsurface]","apttypedds('city),","apttypedds('city).cast[double]","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.join(citiinfotypedds,","apttypedds.makeudf(pricemodifier)","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds2","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","are:","area","argument","arguments)","ariti","arity.","around","array((joe,map(0","array[(username,","as:","as[long]","as[t]","associ","assum","at[long]","avail","available,","available.","averag","averageable:","avg(aptds('price)),","avg(aptds('surface)),","avg,","avgprice:","avgprice|","avgsurface:","avgsurface|minsurface|","avoid","away:","b","b):","b.","b:","b]","bar","bar(1)))","bar(1.1,","bar(d:","bar(i:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","before.","behav","below","benefit","besid","bestneighborhood","better","between","bigint","bigint))","bigint,","bigint]","bind","birthday:","block","boolean","boolean)","boolean):","boolean)]","boolean)].","boolean,","bootstrap","both","break","bring","bug","build.sbt","built","bulletproof:","c:","calcul","call","can't","can't,","captur","case","case.","cast","cast(10","cast,","cat","catalyst","catalystcast.","catalystcast[string,","catch","cats\"","cats.implicits.","cats.implicits._","cats:","caus","cest","chang","channel","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name))","city:","cityinfo","cityinfo(city:","citymapentry(","citymaptf:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|surface|","class","class:","classes)","classes.","claus","clause.","clearli","closur","closures.","code","code.","collect","collectset(aptds('city))","column","column:","columnar","columns,","columns.","columns:","combin","come","common","commonli","compar","comparison,","compat","compil","compile.","compile:","compiles:","complet","complex","compos","composit","comprehens","compromis","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","concept","concept:","conduct","conf","consid","consist","consol","construct","contain","content","context","continu","contribut","contributor","conveni","correct","correct.","correctli","correspond","cough","count","count:","countandtakejob","coupl","creat","current","custom","customizable,","d.gettime()","d:","data","data,","data.","data:","datafram","dataframe,","dataframes,","dataset","dataset\"","dataset.","dataset:","dataset?.","dataset[daterange]","dataset[long].","datasets,","daterange(s:","datetolonginject","datetolonginjection:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","decod","def","default","defin","definit","depend","deprec","deriv","derived,","description.","design","detail","detail.","detect","develop","differ","different,","directli","discuss","discussion.","disk","dive","divid","document","documented.","doesn't","domain","done","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","ds","ds.collect()","ds.filter($\"i\"","ds.filter(_.i","ds.show()","ds:","due","e:","each","earli","easi","easier","easili","element","elements:","elid","enabl","enabled.","encod","encoder.","encoder:","encoders,","enhanc","enough","ensur","entir","environ","equalto(i,10)],","error","error.","error:","essenti","etc)","etc.","everyth","evid","exactli","exampl","example,","example.","example:","except","execut","exist","existence)","expect","expected:","expens","explain","explan","explicit","explicitli","express","extend","extra","extrem","e|","f","f.neighborhood))","f.residents.split('","fact","fail","failure:","familiar","family(residents:","family:","fd","fds('i)","fds('x)","fds.filter(","fds:","featur","femal","few","field","field]","fields.","fields]","file","file.","file:/tmp/foo,","filter","filter(conditionexpr:","filteredd","filteredds.explain()","filteredds.show()","filteredds:","finaljob","finaljob.","finaljob:","find","first","first,","five","flat","focu","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo(s:","foo,","foo.","foodate(i:","form","format","format:","found","frameless","frameless'","frameless.","frameless._","frameless.catalystaverageable[string,out]","frameless.catalystcast[string,double]","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.cats.implicits._","frameless.cats.outer._","frameless.functions.aggregate._","frameless.implicits.widen._","frameless.injection$$anon$1@2ac4b462","frameless.injection$$anon$1@7a09999d","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.job","frameless.job$$anon$2@7b8ecc47","frameless.job$$anon$4@4e32dea0","frameless.job[int]","frameless.job[seq[foo]]","frameless.job[seq[int]])frameless.job[int]","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[apartment,double])(implicit","frameless.typeddatafram","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[foo]","frameless.typeddataset[int]","frameless.typeddataset[person]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless.typedencoder[mydate]","frameless.typedencoder[person]","frameless:","framelessvers","framelessversion,","friend.","friendli","full","fulli","function","function:","functions:","further","futur","g8","gender","gender)","gender:","gendertoint:","gener","general).","generated.","get","giter8","github,","gitter)","give","given","go","goal","goal:","goe","great!","ground,","group","groupbi","groupby()","guard","handhold","handl","have","help","here","here.","here:","hierarchi","hold","however,","http://opensource.org/licenses/apach","i:","id","ident","if(nam","imario","imarios/frameless.g8","implement","implicit","implicitli","implicits.scala:18","implicits.scala:43","import","improv","inabl","incompat","inform","initi","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","input","inputpaths:","insid","instal","instanc","instances:","instanti","instead","int","int)","int).","int)]","int,","int.","int]","interest","intermedi","intern","introduc","introduct","intuitively,","invert(b:","invert(l:","issues.","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date(system.currenttimemillis))))","java.util.date)","java.util.date))","java.util.date)))","java.util.date))))","java.util.date).gettime(),","java.util.date):","java.util.date,","java.util.date.","jeremyrsmith","job","job[a]","job[a],","job[int]","job[seq[int]]):","jobs.","joe","join","join1(tf1:","join2(tf1:","joins,","jvm","j|","kanterov","keep","key","key.","keys.","know","languag","language:postfixops.","larg","last","lazi","lazili","lazy,","lazy.","lead","learning.","less","let","let'","letter","level","leverag","librari","librarydepend","licens","lift","like,","limit","limitations.","line","linux","list(","list(person(42,male))","list(person(42,mon","load","localrel","long","long)","long)))","long):","long)])","long,","long:","long]","look","lyon]|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","mac","macro","made","main","maintain","make","makerdd","male","male))","manag","manipul","manner.","map","map(\"task1\"","map(\"task3\"","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[10]","mapvalu","materialize.","math","matter","max,","meaning","mechan","member","members.","mention","merg","method","method.","min\").","min(aptds('surface)),","min,","minimum","minsurface:","mirror","misspel","mistak","model","moder","modules:","monad","more","much","mydat","mydate(jday:","n","n:","name","name.exists(set('x',","name:","names,","natur","need","needed:","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","new","newinstance(class","next","next,","nice,","nice|","nice|325000.0|","nil","nil)","nlplib","nlplib.uniquename(p.name)","non","not,","note","notifi","now","now,","number,","obj#103:","obj#104:","object","obtain","obviou","offer","ok","olivierblanvillain","on","onc","ontypeddataframe.","onward.","oper","operations:","optim","optimizer)","option","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:58)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:77)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:61)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$8.apply(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2$1.apply(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionup$1(queryplan.scala:269)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:592)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:598)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:425)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:69)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:308)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:126)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:186)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:307)","org.apache.spark.sql.datafram","org.apache.spark.sql.dataset","org.apache.spark.sql.dataset$.ofrows(dataset.scala:64)","org.apache.spark.sql.dataset.(dataset.scala:161)","org.apache.spark.sql.dataset.(dataset.scala:167)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2603)","org.apache.spark.sql.dataset.select(dataset.scala:1023)","org.apache.spark.sql.dataset.select(dataset.scala:969)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:274)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:49)","org.apache.spark.sql.sparksess","org.apache.spark.sql.sqlcontext","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:47)","org.apache.spark.{sparkconf,","os","outer","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","overflow","overload","overview","p","packag","pair","parallelcollectionrdd[0]","parallelcollectionrdd[1]","parallelcollectionrdd[3]","parallelcollectionrdd[5]","parallelcollectionrdd[6]","paramet","parquet","parquetformat,","part","partial","particular","partitionfilters:","pass","peopl","people:","per","perform","performance.","performances.","perhap","person","person(age:","person(name:","person(r,","persond","personds:","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","physic","place","plan","plan,","plan.","plan:","point,","popul","popular","population:","possibl","postfix","practic","precis","predicates.","predict","prefer","preserv","previous","price","price#208]","price,","price/surfac","price:","price:double)","price];;","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.collect.run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","primit","println(data.cmax)","println(data.cmin)","println(data.csum)","problem","problem.","proce","process","product","product,","product.","program","programm","project","project:","proof","prove","provid","public","pull","pushedfilters:","queri","question","quick","q|","rais","ratio","ratio:","ratio|","rdd","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","read","readability.","readabl","readi","readschema).","readschema:","reasons,","recurs","reducebykey","refer","referenc","reflect","relation[i#69l,j#70]","releases.","remind","repl\").set(\"spark.ui.enabled\",","represent","requests)","requests.","requir","res10:","res11:","res17:","res2:","res6:","res7:","res8:","residents:","resolut","resolv","resolver.sonatyperepo(\"releases\")","result","rethought","retriev","return","right","right?","root","row","run","run()","runtim","s:","sadly,","safe","safe,","safe.","safety!","safety,","safety.","same","sample.map(_.min)","save","say,","sbt","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala","scala.","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.immutable.map[string,int])]","scala.collection.map[string,scala.collection.immutable.map[string,int]]","scala.collection.map[user,transactioncount]","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala.language.postfixop","scala.language.postfixops'","scala>","scaladoc","scalareflect","schema","schema.","seal","second","second,","section","see","see,","seem","select","select()","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","selectmany()","selectmany,","semigroup","separately,","seq(","seq(person(42,","seq[(string,","seq[double]","seq[person]","sequenc","serial","serializ","serv","set","sever","shadow","shapeless","shapeless.hlist","shapeless.tag.tagged[string(\"citi\")]","shapeless.tag.tagged[string(\"x\")]","shell","shorter","show","show()","showcas","shown","shuffledrdd[2]","shuffledrdd[4]","sign","signatur","signatures:","similar","similar)","simpl","simplifi","simplist","simply:","singl","situat","size","skip","slow","small","solut","solv","sort","spark","spark'","spark).","spark,","spark.","spark.createdataset(","spark.createdataset(apartments)","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark.sparkcontext.setloglevel(\"warn\")","spark.sqlcontext","spark:","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparksess","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","sqlcontext","sqlcontext):","sqlcontext.createdataset(seq(daterange(new","stack","stage","standard","start","stat","statement","statement).","stats(","still","store","strict","string","string)","string),updatedsurface]","string):","string)]","string)])","string,","string]","strongli","struct","struct,","struct]","subset","suffici","suggests,","summari","support","suppos","surfac","surface#207,","surface,","surface,th","surface:","symbol","syntax","syntax.","syntax:","syntaxes,","system","systems,","t","t:","tabl","table,","tables:","take","target","task","task2","task3","tdataframe[schema","tdataframe[schema]","techniqu","tell","ten","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","thing","this.","thought","three","time","time,","time.","time:","timeseri","timeseries)]","togeth","together.","top","totalperus","totalperuser.collectasmap","totalperuser:","toy","trace):","trace,","track","track,","trait","transactioncount","transactioncount)]","transform","tri","troubl","true]","tupl","tuple23","tutori","two","type","type,","type.","type:","typeclass:","typedcolumn","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry]","typeddataframe[citymapentry])","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","typeddataset","typeddataset,","typeddataset.","typeddataset.create(1","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset.create(ds)","typeddataset.create(people)","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset.create(seq(mydate(new","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","typeddatset","typedencod","typeencod","typelevel","types,","types.","types:","typesaf","typo","typo,","u","udf","udf(aptds('city),","udf:","ui","unabl","under","unfortunately,","uniqu","uniquename(name:","unit:","unlik","unsaf","up","up,","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","user'","usernam","val","valid","valu","value#105l]","vanilla","variou","vector[string])","verbos","veri","version","versions.","via","view","visible.","want","warning:","way","well","well,","wherea","why?","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withdescription(\"sampl","withgroupid(\"samplingjob\").","without","won't","work","worked,","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","w|","x","x:","zero.","{","|","|+|","|1000|102|","|100|","|276333.3333333333|62.833333333333336|","|4500.0|450000.0|","|6000.0|300000.0|","|[paris,100,450000.0]|[paris,2229621]|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|value|","}","})","},"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"Introduction","keywords":"","body":"Frameless\n\n\n\n\nFrameless is a proof-of-concept library for working with Spark using more expressive types.\nIt consists of the following modules:\n\ndataset for more strongly typed Datasets  (supports Spark 2.0.x)\ncats for using Spark with cats (supports Cats 0.9.x)\n\nThe Frameless project and contributors support the\nTypelevel Code of Conduct and want all its\nassociated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning.\nDocumentation\n\nTypedDataset: Feature Overview\nComparing TypedDatasets with Spark's Datasets\nTyped Encoders in Frameless\nInjection: Creating Custom Encoders\nUsing Cats with RDDs\nProof of Concept: TypedDataFrame\n\nWhy?\nBenefits of using TypedDataset compared to the standard Spark Dataset API:\n\nTypesafe columns referencing and expressions\nCustomizable, typesafe encoders\nTypesafe casting and projections\nEnhanced type signature for some built-in functions\n\nQuick Start\nFrameless is compiled against Scala 2.11.x.\nNote that while Frameless is still getting off the ground, it is very possible that breaking changes will be\nmade for at least the next few versions.\nTo use Frameless in your project add the following in your build.sbt file as needed:\nresolvers += Resolver.sonatypeRepo(\"releases\")\n\nval framelessVersion = \"0.3.0\"\n\nlibraryDependencies ++= List(\n  \"org.typelevel\" %% \"frameless-cats\"      % framelessVersion,\n  \"org.typelevel\" %% \"frameless-dataset\"   % framelessVersion\n)\n\nAn easy way to bootstrap a Frameless sbt project:\n\nif you have Giter8 installed then simply:\n\ng8 imarios/frameless.g8\n\n\nwith sbt >= 0.13.13:\n\nsbt new imarios/frameless.g8\n\nTyping sbt console inside your project will bring up a shell with Frameless\nand all its dependencies loaded (including Spark).\nDevelopment\nWe require at least one sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers\n(people who can merge pull requests) are:\n\nadelbertc\nimarios\njeremyrsmith\nkanterov\nnon\nOlivierBlanvillain\n\nLicense\nCode is provided under the Apache 2.0 license available at http://opensource.org/licenses/Apache-2.0,\nas well as in the LICENSE file. This is the same license used as Spark.\n"},"FeatureOverview.html":{"url":"FeatureOverview.html","title":"TypedDataset: Feature Overview","keywords":"","body":"TypedDataset: Feature Overview\nThis tutorial introduces TypedDataset using a simple example.\nThe following imports are needed to make all code examples compile.\nimport org.apache.spark.{SparkConf, SparkContext}\nimport org.apache.spark.sql.SparkSession\nimport frameless.functions.aggregate._\nimport frameless.TypedDataset\n\nval conf = new SparkConf().setMaster(\"local[*]\").setAppName(\"frameless repl\").set(\"spark.ui.enabled\", \"false\")\nval spark = SparkSession.builder().config(conf).appName(\"REPL\").getOrCreate()\nimplicit val sqlContext = spark.sqlContext\nspark.sparkContext.setLogLevel(\"WARN\")\n\nimport spark.implicits._\n\nCreating TypedDataset instances\nWe start by defining a case class:\ncase class Apartment(city: String, surface: Int, price: Double)\n\nAnd few Apartment instances:\nval apartments = Seq(\n  Apartment(\"Paris\", 50, 300000.0),\n  Apartment(\"Paris\", 100, 450000.0),\n  Apartment(\"Paris\", 25, 250000.0),\n  Apartment(\"Lyon\", 83, 200000.0),\n  Apartment(\"Lyon\", 45, 133000.0),\n  Apartment(\"Nice\", 74, 325000.0)\n)\n\nWe are now ready to instantiate a TypedDataset[Apartment]:\nval aptTypedDs = TypedDataset.create(apartments)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nWe can also create one from an existing Spark Dataset:\nval aptDs = spark.createDataset(apartments)\n// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nval aptTypedDs = TypedDataset.create(aptDs)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nOr use the Frameless syntax:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval aptTypedDs2 = aptDs.typed\n// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nTypesafe column referencing\nThis is how we select a particular column from a TypedDataset:\nval cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))\n// cities: frameless.TypedDataset[String] = [_1: string]\n\nThis is completely type-safe, for instance suppose we misspell city as citi:\naptTypedDs.select(aptTypedDs('citi))\n// :28: error: No column Symbol with shapeless.tag.Tagged[String(\"citi\")] of type A in Apartment\n//        aptTypedDs.select(aptTypedDs('citi))\n//                                    ^\n\nThis gets raised at compile-time, whereas with the standard Dataset API the error appears at run-time (enjoy the stack trace):\naptDs.select('citi)\n// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [city, surface, price];;\n// 'Project ['citi]\n// +- LocalRelation [city#206, surface#207, price#208]\n// \n//   at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:77)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:74)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:69)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:307)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionUp$1(QueryPlan.scala:269)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:279)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2$1.apply(QueryPlan.scala:283)\n//   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n//   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n//   at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)\n//   at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)\n//   at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n//   at scala.collection.AbstractTraversable.map(Traversable.scala:104)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:283)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$8.apply(QueryPlan.scala:288)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:186)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:288)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:74)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:67)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:126)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:67)\n//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:58)\n//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:49)\n//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:64)\n//   at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2603)\n//   at org.apache.spark.sql.Dataset.select(Dataset.scala:969)\n//   ... 458 elided\n\nselect() supports arbitrary column operations:\naptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()\n// +----+---+\n// |  _1| _2|\n// +----+---+\n// | 500| 52|\n// |1000|102|\n// | 250| 27|\n// | 830| 85|\n// | 450| 47|\n// | 740| 76|\n// +----+---+\n//\n\nNote that unlike the standard Spark API where some operations are lazy and some are not, TypedDatasets have all operations to be lazy. \nIn the above example, show() is lazy. It requires to apply run() for the show job to materialize.\nA more detailed explanation of Job is given here.\nNext we compute the price by surface unit:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// :27: error: overloaded method value / with alternatives:\n//   (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] \n//   (u: frameless.TypedColumn[Apartment,Double])(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double]\n//  cannot be applied to (frameless.TypedColumn[Apartment,Int])\n//        val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n//                                                                      ^\n\nAs the error suggests, we can't divide a TypedColumn of Double by Int. \nFor safety, in Frameless only math operations between same types is allowed. \nThere are two ways to proceed here: \n(a) Explicitly cast Int to Double (manual)\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect().run()\n// res6: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\n(b) Perform the cast implicitly (automated)\nimport frameless.implicits.widen._\n// import frameless.implicits.widen._\n\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect.run()\n// res7: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\nLooks like it worked, but that cast seems unsafe right? Actually it is safe.\nLet's try to cast a TypedColumn of String to Double:\naptTypedDs('city).cast[Double]\n// :31: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]\n//        aptTypedDs('city).cast[Double]\n//                              ^\n\nThe compile-time error tells us that to perform the cast, an evidence \n(in the form of CatalystCast[String, Double]) must be available. \nSince casting from String to Double is not allowed, this results \nin a compilation error. \nCheck here \nfor the set of available CatalystCast.\nTypeSafe TypedDataset casting and projections\nWith select() the resulting TypedDataset is of type TypedDataset[TupleN[...]] (with N in [1...10]).\nFor example, if we select three columns with types String, Int, and Boolean the result will have type\nTypedDataset[(String, Int, Boolean)]. To select more than ten columns use the selectMany() method. \nSelect has better IDE support than the macro based selectMany, so prefer select() for the general case. \nWe often want to give more expressive types to the result of our computations.\nas[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long\nas the types in U and T align.\nWhen the cast is valid the expression compiles:\ncase class UpdatedSurface(city: String, surface: Int)\n// defined class UpdatedSurface\n\nval updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]\n// updated: frameless.TypedDataset[UpdatedSurface] = [city: string, surface: int]\n\nupdated.show(2).run()\n// +-----+-------+\n// | city|surface|\n// +-----+-------+\n// |Paris|     52|\n// |Paris|    102|\n// +-----+-------+\n// only showing top 2 rows\n//\n\nNext we try to cast a (String, String) to an UpdatedSurface (which has types String, Int).\nThe cast is not valid and the expression does not compile:\naptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// :33: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]\n//        aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n//                                                                  ^\n\nProjections\nWe often want to work with a subset of the fields in a dataset.\nProjections allows to easily select the fields we are interested\nwhile preserving their initial name and types for extra safety.\nHere is an example using the TypedDataset[Apartment] with an additional column:\nimport frameless.implicits.widen._\n// import frameless.implicits.widen._\n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\ncase class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)\n// defined class ApartmentDetails\n\nval aptWithRatio = aptds.select(aptds('city), aptds('price), aptds('surface), aptds('price) / aptds('surface)).as[ApartmentDetails]\n// aptWithRatio: frameless.TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]\n\nSuppose we only want to work with city and ratio:\ncase class CityInfo(city: String, ratio: Double)\n// defined class CityInfo\n\nval cityRatio = aptWithRatio.project[CityInfo]\n// cityRatio: frameless.TypedDataset[CityInfo] = [city: string, ratio: double]\n\ncityRatio.show(2).run()\n// +-----+------+\n// | city| ratio|\n// +-----+------+\n// |Paris|6000.0|\n// |Paris|4500.0|\n// +-----+------+\n// only showing top 2 rows\n//\n\nSuppose we only want to work with price and ratio:\ncase class PriceInfo(ratio: Double, price: Double)\n// defined class PriceInfo\n\nval priceInfo = aptWithRatio.project[PriceInfo]\n// priceInfo: frameless.TypedDataset[PriceInfo] = [ratio: double, price: double]\n\npriceInfo.show(2).run()\n// +------+--------+\n// | ratio|   price|\n// +------+--------+\n// |6000.0|300000.0|\n// |4500.0|450000.0|\n// +------+--------+\n// only showing top 2 rows\n//\n\nWe see that the order of the fields does not matter as long as the\nnames and the corresponding types agree. However, if we make a mistake in\nany of the names and/or their types, then we get a compilation error.\nSay we make a typo in a field name:\ncase class PriceInfo2(ratio: Double, pricEE: Double)\n\naptWithRatio.project[PriceInfo2]\n// :36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?\n//        aptWithRatio.project[PriceInfo2]\n//                            ^\n\nSay we make a mistake in the corresponding type:\ncase class PriceInfo3(ratio: Int, price: Double) // ratio should be Double\n\naptWithRatio.project[PriceInfo3]\n// :36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?\n//        aptWithRatio.project[PriceInfo3]\n//                            ^\n\nUser Defined Functions\nFrameless supports lifting any Scala function (up to five arguments) to the\ncontext of a particular TypedDataset:\n// The function we want to use as UDF\nval priceModifier =\n    (name: String, price:Double) => if(name == \"Paris\") price * 2.0 else price\n// priceModifier: (String, Double) => Double = \n\nval udf = aptTypedDs.makeUDF(priceModifier)\n// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = \n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nval adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))\n// adjustedPrice: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\nadjustedPrice.show().run()\n// +-----+--------+\n// |   _1|      _2|\n// +-----+--------+\n// |Paris|600000.0|\n// |Paris|900000.0|\n// |Paris|500000.0|\n// | Lyon|200000.0|\n// | Lyon|133000.0|\n// | Nice|325000.0|\n// +-----+--------+\n//\n\nGroupBy and Aggregations\nLet's suppose we wanted to retrieve the average apartment price in each city\nval priceByCity = aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('price)))\n// priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\npriceByCity.collect().run()\n// res17: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))\n\nAgain if we try to aggregate a column that can't be aggregated, we get a compilation error\naptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                         ^\n// :34: error: could not find implicit value for parameter averageable: frameless.CatalystAverageable[String,Out]\n//        aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                         ^\n//                                                     ^\n// :34: warning: postfix operator ^ should be enabled\n// by making the implicit value scala.language.postfixOps visible.\n// This can be achieved by adding the import clause 'import scala.language.postfixOps'\n// or by setting the compiler option -language:postfixOps.\n// See the Scaladoc for value scala.language.postfixOps for a discussion\n// why the feature should be explicitly enabled.\n//        aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                         ^\n//                                                                                                                                  ^\n\nNext, we combine select and groupBy to calculate the average price/surface ratio per city:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nval cityPriceRatio =  aptds.select(aptds('city), aptds('price) / aptds('surface))\n// cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\ncityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()\n// +-----+------------------+\n// |   _1|                _2|\n// +-----+------------------+\n// | Nice| 4391.891891891892|\n// |Paris| 6833.333333333333|\n// | Lyon|2682.5970548862115|\n// +-----+------------------+\n//\n\nEntire TypedDataset Aggregation\nWe often want to aggregate the entire TypedDataset and skip the groupBy() clause.\nIn Frameless you can do this using the agg() operator directly on the TypedDataset. \nIn the following example, we compute the average price, the average surface,the minimum surface, and the set of cities for the entire dataset. \ncase class Stats(\n   avgPrice: Double, \n   avgSurface: Double, \n   minSurface: Int, \n   allCities: Vector[String])\n// defined class Stats\n\naptds.agg(\n   avg(aptds('price)), \n   avg(aptds('surface)),\n   min(aptds('surface)),\n   collectSet(aptds('city))\n).as[Stats].show().run() \n// +-----------------+------------------+----------+-------------------+\n// |         avgPrice|        avgSurface|minSurface|          allCities|\n// +-----------------+------------------+----------+-------------------+\n// |276333.3333333333|62.833333333333336|        25|[Paris, Nice, Lyon]|\n// +-----------------+------------------+----------+-------------------+\n//\n\nJoins\ncase class CityPopulationInfo(name: String, population: Int)\n\nval cityInfo = Seq(\n  CityPopulationInfo(\"Paris\", 2229621),\n  CityPopulationInfo(\"Lyon\", 500715),\n  CityPopulationInfo(\"Nice\", 343629)\n)\n\nval citiInfoTypedDS = TypedDataset.create(cityInfo)\n\nHere is how to join the population information to the apartment's dataset.\nval withCityInfo = aptTypedDs.join(citiInfoTypedDS, aptTypedDs('city), citiInfoTypedDS('name))\n// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct, _2: struct]\n\nwithCityInfo.show().run()\n// +--------------------+---------------+\n// |                  _1|             _2|\n// +--------------------+---------------+\n// | [Paris,50,300000.0]|[Paris,2229621]|\n// |[Paris,100,450000.0]|[Paris,2229621]|\n// | [Paris,25,250000.0]|[Paris,2229621]|\n// |  [Lyon,83,200000.0]|  [Lyon,500715]|\n// |  [Lyon,45,133000.0]|  [Lyon,500715]|\n// |  [Nice,74,325000.0]|  [Nice,343629]|\n// +--------------------+---------------+\n//\n\nThe joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].\nWe can then select which information we want to continue to work with:\ncase class AptPriceCity(city: String, aptPrice: Double, cityPopulation: Int)\n// defined class AptPriceCity\n\nwithCityInfo.select(\n   withCityInfo.colMany('_2, 'name), withCityInfo.colMany('_1, 'price), withCityInfo.colMany('_2, 'population)\n).as[AptPriceCity].show().run\n// +-----+--------+--------------+\n// | city|aptPrice|cityPopulation|\n// +-----+--------+--------------+\n// |Paris|300000.0|       2229621|\n// |Paris|450000.0|       2229621|\n// |Paris|250000.0|       2229621|\n// | Lyon|200000.0|        500715|\n// | Lyon|133000.0|        500715|\n// | Nice|325000.0|        343629|\n// +-----+--------+--------------+\n//\n\n"},"TypedDatasetVsSparkDataset.html":{"url":"TypedDatasetVsSparkDataset.html","title":"Comparing TypedDatasets with Spark's Datasets","keywords":"","body":"Comparing TypedDatasets with Spark's Datasets\nGoal:\n  This tutorial compares the standard Spark Datasets api with the one provided by\n  frameless' TypedDataset. It shows how TypedDatsets allows for an expressive and\n  type-safe api with no compromises on performance.\nFor this tutorial we first create a simple dataset and save it on disk as a parquet file.\nParquet is a popular columnar format and well supported by Spark.\nIt's important to note that when operating on parquet datasets, Spark knows that each column is stored\nseparately, so if we only need a subset of the columns Spark will optimize for this and avoid reading\nthe entire dataset. This is a rather simplistic view of how Spark and parquet work together but it\nwill serve us well for the context of this discussion.\nimport spark.implicits._\n// import spark.implicits._\n\n// Our example case class Foo acting here as a schema\ncase class Foo(i: Long, j: String)\n// defined class Foo\n\n// Assuming spark is loaded and SparkSession is bind to spark\nval initialDs = spark.createDataset( Foo(1, \"Q\") :: Foo(10, \"W\") :: Foo(100, \"E\") :: Nil )\n// initialDs: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\n// Assuming you are on Linux or Mac OS\ninitialDs.write.parquet(\"/tmp/foo\")\n\nval ds = spark.read.parquet(\"/tmp/foo\").as[Foo]\n// ds: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\nds.show()\n// +---+---+\n// |  i|  j|\n// +---+---+\n// | 10|  W|\n// |100|  E|\n// |  1|  Q|\n// +---+---+\n//\n\nThe value ds holds the content of the initialDs read from a parquet file.\nLet's try to only use field i from Foo and see how Spark's Catalyst (the query optimizer)\noptimizes this.\n// Using a standard Spark TypedColumn in select()\nval filteredDs = ds.filter($\"i\" === 10).select($\"i\".as[Long])\n// filteredDs: org.apache.spark.sql.Dataset[Long] = [i: bigint]\n\nfilteredDs.show()\n// +---+\n// |  i|\n// +---+\n// | 10|\n// +---+\n//\n\nThe filteredDs is of type Dataset[Long]. Since we only access field i from Foo the type is correct.\nUnfortunately, this syntax requires handholding by explicitly setting the TypedColumn in the select statement\nto return type Long (look at the as[Long] statement). We will discuss this limitation next in more detail.\nNow, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.\nfilteredDs.explain()\n// == Physical Plan ==\n// *Project [i#69L]\n// +- *Filter (isnotnull(i#69L) && (i#69L = 10))\n//    +- *BatchedScan parquet [i#69L] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nThe last line is very important (see ReadSchema). The schema read\nfrom the parquet file only required reading column i without needing to access column j.\nThis is great! We have both an optimized query plan and type-safety!\nUnfortunately, this syntax is not bulletproof: it fails at run-time if we try to access\na non existing column x:\nscala> ds.filter($\"i\" === 10).select($\"x\".as[Long])\norg.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];;\n'Project ['x]\n+- Filter (i#69L = cast(10 as bigint))\n   +- Relation[i#69L,j#70] parquet\n\n  at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:77)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:74)\n  at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n  at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n  at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:69)\n  at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:307)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionUp$1(QueryPlan.scala:269)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:279)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2$1.apply(QueryPlan.scala:283)\n  at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n  at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n  at scala.collection.immutable.List.foreach(List.scala:392)\n  at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n  at scala.collection.immutable.List.map(List.scala:296)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:283)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$8.apply(QueryPlan.scala:288)\n  at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:186)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:288)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:74)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:67)\n  at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:126)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:67)\n  at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:58)\n  at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:49)\n  at org.apache.spark.sql.Dataset.(Dataset.scala:161)\n  at org.apache.spark.sql.Dataset.(Dataset.scala:167)\n  at org.apache.spark.sql.Dataset.select(Dataset.scala:1023)\n  ... 450 elided\n\nThere are two things to improve here. First, we would want to avoid the at[Long] casting that we are required\nto type for type-safety. This is clearly an area where we can introduce a bug by casting to an incompatible\ntype. Second, we want a solution where reference to a\nnon existing column name fails at compilation time.\nThe standard Spark Dataset can achieve this using the following syntax.\nds.filter(_.i == 10).map(_.i).show()\n// +-----+\n// |value|\n// +-----+\n// |   10|\n// +-----+\n//\n\nThis looks great! It reminds us the familiar syntax from Scala.\nThe two closures in filter and map are functions that operate on Foo and the\ncompiler will helps us capture all the mistakes we mentioned above.\nscala> ds.filter(_.i == 10).map(_.x).show()\n:20: error: value x is not a member of Foo\n       ds.filter(_.i == 10).map(_.x).show()\n                                  ^\n\nUnfortunately, this syntax does not allow Spark to optimize the code.\nds.filter(_.i == 10).map(_.i).explain()\n// == Physical Plan ==\n// *SerializeFromObject [input[0, bigint, true] AS value#105L]\n// +- *MapElements , obj#104: bigint\n//    +- *DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#103: $line14.$read$$iw$$iw$$iw$$iw$Foo\n//       +- *Filter .apply\n//          +- *BatchedScan parquet [i#69L,j#70] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [], ReadSchema: struct\n\nAs we see from the explained Physical Plan, Spark was not able to optimize our query as before.\nReading the parquet file will required loading all the fields of Foo. This might be ok for\nsmall datasets or for datasets with few columns, but will be extremely slow for most practical\napplications.\nIntuitively, Spark currently doesn't have a way to look inside the code we pass in these two\nclosures. It only knows that they both take one argument of type Foo, but it has no way of knowing if\nwe use just one or all of Foo's fields.\nThe TypedDataset in frameless solves this problem. It allows for a simple and type-safe syntax\nwith a fully optimized query plan.\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nval fds = TypedDataset.create(ds)\n// fds: frameless.TypedDataset[Foo] = [i: bigint, j: string]\n\nfds.filter( fds('i) === 10 ).select( fds('i) ).show().run()\n// +---+\n// | _1|\n// +---+\n// | 10|\n// +---+\n//\n\nAnd the optimized Physical Plan:\nfds.filter( fds('i) === 10 ).select( fds('i) ).explain()\n// == Physical Plan ==\n// *Project [i#69L AS _1#176L]\n// +- *Filter (isnotnull(i#69L) && (i#69L = 10))\n//    +- *BatchedScan parquet [i#69L] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nAnd the compiler is our friend.\nscala> fds.filter( fds('i) === 10 ).select( fds('x) )\n:21: error: No column Symbol with shapeless.tag.Tagged[String(\"x\")] of type A in Foo\n       fds.filter( fds('i) === 10 ).select( fds('x) )\n                                               ^\n\nDifferences in Encoders\nEncoders in Spark's Datasets are partially type-safe. If you try to create a Dataset using  a type that is not \n a Scala Product then you get a compilation error:\nclass Bar(i: Int)\n// defined class Bar\n\nBar is neither a case class nor a Product, so the following correctly gives a compilation error in Spark:\nscala> spark.createDataset(Seq(new Bar(1)))\n:21: error: Unable to find encoder for type stored in a Dataset.  Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._  Support for serializing other types will be added in future releases.\n       spark.createDataset(Seq(new Bar(1)))\n                          ^\n\nHowever, the compile type guards implemented in Spark are not sufficient to detect non encodable members. \nFor example, using the following case class leads to a runtime failure:\ncase class MyDate(jday: java.util.Date)\n// defined class MyDate\n\nval myDateDs = spark.createDataset(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// java.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n// - field (class: \"java.util.Date\", name: \"jday\")\n// - root class: \"MyDate\"\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:598)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:592)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:583)\n//   at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n//   at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n//   at scala.collection.immutable.List.foreach(List.scala:392)\n//   at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n//   at scala.collection.immutable.List.flatMap(List.scala:355)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:583)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:425)\n//   at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:61)\n//   at org.apache.spark.sql.Encoders$.product(Encoders.scala:274)\n//   at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:47)\n//   ... 770 elided\n\nIn comparison, a TypedDataset will notify about the encoding problem at compile time: \nTypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// :22: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[MyDate]\n//        TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n//                           ^\n\n"},"TypedEncoder.html":{"url":"TypedEncoder.html","title":"Typed Encoders in Frameless","keywords":"","body":"Typed Encoders in Frameless\nSpark uses Reflection to derive it's Encoders, which is why they can fail at run time. For example, because Spark does not supports java.util.Date, the following leads to an error:\nimport org.apache.spark.sql.Dataset\nimport spark.implicits._\n\ncase class DateRange(s: java.util.Date, e: java.util.Date)\n\nscala> val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))\njava.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n- field (class: \"java.util.Date\", name: \"s\")\n- root class: \"DateRange\"\n  at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:598)\n  at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:592)\n  at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:583)\n  at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n  at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n  at scala.collection.immutable.List.foreach(List.scala:392)\n  at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n  at scala.collection.immutable.List.flatMap(List.scala:355)\n  at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:583)\n  at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:425)\n  at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:61)\n  at org.apache.spark.sql.Encoders$.product(Encoders.scala:274)\n  at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:47)\n  ... 230 elided\n\nAs shown by the stack trace, this runtime error goes thought ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection based approach is it's inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.\nFrameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the code java.util.Date example won't compile with frameless:\nimport frameless.TypedDataset\n\nval ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// :26: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]\n//        val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n//                                                             ^\n\nType class derivation takes case or recursively constructing (and proving the existence) TypeEncoders for case classes. The following works as expected:\ncase class Bar(d: Double, s: String)\n// defined class Bar\n\ncase class Foo(i: Int, b: Bar)\n// defined class Foo\n\nval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, \"s\"))))\n// ds: frameless.TypedDataset[Foo] = [i: int, b: struct]\n\nds.collect()\n// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@4e32dea0\n\nBut any non-encodable in the case class hierarchy will be detected at compile time:\ncase class BarDate(d: Double, s: String, t: java.util.Date)\ncase class FooDate(i: Int, b: BarDate)\n\nval ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// :28: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]\n//        val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n//                                                           ^\n\nIt should be noted that once derived, reflection based Encoders and implicitly derived TypeEncoders have identical performances. The derivation mechanism is different, but the objects generated to encode and decode JVM object in the Spark internal representation behave the same at run-time.\n"},"Injection.html":{"url":"Injection.html","title":"Injection: Creating Custom Encoders","keywords":"","body":"Injection: Creating Custom Encoders\nInjection lets us define encoders for types that do not have one by injecting A into an encodable type B.\nThis is the definition of the injection typeclass:\ntrait Injection[A, B] extends Serializable {\n  def apply(a: A): B\n  def invert(b: B): A\n}\n\nExample\nLet's define a simple case class:\ncase class Person(age: Int, birthday: java.util.Date)\n// defined class Person\n\nval people = Seq(Person(42, new java.util.Date))\n// people: Seq[Person] = List(Person(42,Mon May 22 09:53:10 CEST 2017))\n\nAnd an instance of a TypedDataset:\nval personDS = TypedDataset.create(people)\n// :24: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n//        val personDS = TypedDataset.create(people)\n//                                          ^\n\nLooks like we can't, a TypedEncoder instance of Person is not available, or more precisely for java.util.Date.\nBut we can define a injection from java.util.Date to an encodable type, like Long:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = new Injection[java.util.Date, Long] {\n  def apply(d: java.util.Date): Long = d.getTime()\n  def invert(l: Long): java.util.Date = new java.util.Date(l)\n}\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@6cd5eaec\n\nWe can be less verbose using the Injection.apply function:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@7a09999d\n\nNow we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, birthday: bigint]\n\nAnother example\nLet's define a sealed family:\nsealed trait Gender\n// defined trait Gender\n\ncase object Male extends Gender\n// defined object Male\n\ncase object Female extends Gender\n// defined object Female\n\ncase object Other extends Gender\n// defined object Other\n\nAnd a simple case class:\ncase class Person(age: Int, gender: Gender)\n// defined class Person\n\nval people = Seq(Person(42, Male))\n// people: Seq[Person] = List(Person(42,Male))\n\nAgain if we try to create a TypedDataset, we get a compilation error.\nval personDS = TypedDataset.create(people)\n// :32: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n//        val personDS = TypedDataset.create(people)\n//                                          ^\n\nLet's define an injection instance for Gender:\nimplicit val genderToInt: Injection[Gender, Int] = Injection(\n  {\n    case Male   => 1\n    case Female => 2\n    case Other  => 3\n  },\n  {\n    case 1 => Male\n    case 2 => Female\n    case 3 => Other\n  })\n// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@2ac4b462\n\nAnd now we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, gender: int]\n\n"},"Job.html":{"url":"Job.html","title":"Job[A]","keywords":"","body":"Job[A]\nAll operations on TypedDataset are lazy. An operation either returns a new\ntransformed TypedDataset or a Job[A], where A is the result of running a\nnon-lazy computation in Spark. Job serves several functions:\n\nMakes all operations on a TypedDataset lazy, which makes them more predictable compared to having\nfew operations being lazy and other being strict\nAllows the programmer to make expensive blocking operations explicit\nAllows for Spark jobs to be lazily sequenced using monadic composition via for-comprehension\nProvides an obvious place where you can annotate/name your Spark jobs to make it easier\nto track different parts of your application in the Spark UI\n\nThe toy example showcases the use of for-comprehension to explicitly sequences Spark Jobs.\nFirst we calculate the size of the TypedDataset and then we collect to the driver\nexactly 20% of its elements:\nval ds = TypedDataset.create(1 to 20)\n// ds: frameless.TypedDataset[Int] = [_1: int]\n\nval countAndTakeJob =\n  for {\n    count \nThe countAndTakeJob can either be executed using run() (as we show above) or it can\nbe passed along to other parts of the program to be further composed into more complex sequences\nof Spark jobs.\nimport frameless.Job\n// import frameless.Job\n\ndef computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min)\n// computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]\n\nval finalJob = computeMinOfSample(countAndTakeJob)\n// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@7b8ecc47\n\nNow we can execute this new job by specifying a group-id and a description.\nThis allows the programmer to see this information on the Spark UI and help track, say,\nperformance issues.\nfinalJob.\n  withGroupId(\"samplingJob\").\n  withDescription(\"Samples 20% of elements and computes the min\").\n  run()\n// res2: Int = 1\n\n"},"Cats.html":{"url":"Cats.html","title":"Using Cats with RDDs","keywords":"","body":"Using Cats with RDDs\nData aggregation is one of the most important operations when working with Spark (and data in general).\nFor example, we often have to compute the min, max, avg, etc. from a set of columns grouped by\ndifferent predicates. This section shows how cats simplifies these tasks in Spark by\nleveraging a large collection of Type Classes for ordering and aggregating data.\nAll the examples below assume you have previously imported cats.implicits.\nimport cats.implicits._\n// import cats.implicits._\n\nCats offers ways to sort and aggregate tuples of arbitrary arity.\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nval data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[0] at makeRDD at :21\n\nprintln(data.csum)\n// (10,9,9)\n\nprintln(data.cmax)\n// (8,2,3)\n\nprintln(data.cmin)\n// (1,2,3)\n\nThe following example aggregates all the elements with a common key.\ntype User = String\n// defined type alias User\n\ntype TransactionCount = Int\n// defined type alias TransactionCount\n\nval allData: RDD[(User,TransactionCount)] =\n   sc.makeRDD((\"Bob\", 12) :: (\"Joe\", 1) :: (\"Anna\", 100) :: (\"Bob\", 20) :: (\"Joe\", 2) :: Nil)\n// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[1] at makeRDD at :24\n\nval totalPerUser =  allData.csumByKey\n// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[2] at reduceByKey at implicits.scala:18\n\ntotalPerUser.collectAsMap\n// res7: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)\n\nThe same example would work for more complex keys.\nval allDataComplexKeu =\n   sc.makeRDD( (\"Bob\", Map(\"task1\" -> 10)) ::\n    (\"Joe\", Map(\"task1\" -> 1, \"task2\" -> 3)) :: (\"Bob\", Map(\"task1\" -> 10, \"task2\" -> 1)) :: (\"Joe\", Map(\"task3\" -> 4)) :: Nil )\n// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ParallelCollectionRDD[3] at makeRDD at :22\n\nval overalTasksPerUser = allDataComplexKeu.csumByKey\n// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ShuffledRDD[4] at reduceByKey at implicits.scala:18\n\noveralTasksPerUser.collectAsMap\n// res8: scala.collection.Map[String,scala.collection.immutable.Map[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))\n\nJoins\n// Type aliases for meaningful types\ntype TimeSeries = Map[Int,Int]\n// defined type alias TimeSeries\n\ntype UserName = String\n// defined type alias UserName\n\nExample: Using the implicit full-our-join operator\nimport frameless.cats.outer._\n// import frameless.cats.outer._\n\nval day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 2, 1 -> 4)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Sam\", Map(0 -> 1)) :: Nil )\n// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[5] at makeRDD at :26\n\nval day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 10, 1 -> 11)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Joe\", Map(0 -> 1, 1 -> 2)) :: Nil )\n// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[6] at makeRDD at :26\n\nval daysCombined = day1 |+| day2\n// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[10] at mapValues at implicits.scala:43\n\ndaysCombined.collect()\n// res10: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))\n\nNote how the user's timeseries from different days have been aggregated together.\nThe |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join\non the key and combine values using the default Semigroup for the value type.\nIn cats:\nMap(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)\n// res11: Map[Int,Int] = Map(1 -> 6, 2 -> 2)\n\n"},"TypedDataFrame.html":{"url":"TypedDataFrame.html","title":"Proof of Concept: TypedDataFrame","keywords":"","body":"Proof of Concept: TypedDataFrame\nTypedDataFrame is the API developed in the early stages of frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future developments of frameless. However, the design is interesting enough for being documented.\nTo safely manipulate DataFrames we use a technique called shadow type, which consists in storing additional information about a value in a \"dummy\" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.\nDiving in\nIn TypedDataFrame, we use a single Schema  to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:\nimport org.apache.spark.sql.DataFrame\nimport shapeless.HList\n\nclass TDataFrame[Schema  Boolean): TDataFrame[Schema] = ???\n\n  def select[C \nAs you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.\nType-level column referencing\nFor Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching column referencing at compile type. When everything goes well, frameless select is very similar to vanilla select, except that it keeps track of the selected column types:\nimport frameless.TypedDataFrame\n\ncase class Foo(s: String, d: Double, i: Int)\n\ndef selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n  tf.select('i, 's)\n\nHowever, in case of typo, it gets coughs right away:\ndef selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n  tf.select('j, 's)\n\nType-level joins\nJoins can available with two different syntaxes, the first lets you reference different columns on each TypedDataFrame, and ensures that their all exists and have compatible types:\ncase class Bar(i: Int, j: String, b: Boolean)\n\ndef join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n    : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =\n  tf1.innerJoin(tf2).on('s).and('j)\n\nThe second syntax bring some convenience when the joining columns have identical names in both tables:\ndef join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n    : TypedDataFrame[(String, Double, Int, String, Boolean)] =\n  tf1.innerJoin(tf2).using('i)\n\nFurther example are available in the TypedDataFrame join tests.\nComplete example\nWe now consider a complete example to see how the type system can frameless can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city map and neighborhood:\ntype Neighborhood = String\ntype Address = String\n\ncase class PhoneBookEntry(\n  address: Address,\n  residents: String,\n  phoneNumber: Double\n)\n\ncase class CityMapEntry(\n  address: Address,\n  neighborhood: Neighborhood\n)\n\nOur goal will be to compute the neighborhood with unique names, approximating \"unique\" with names containing less common\nletters in the alphabet: 'x', 'q', and 'z'. We are going to need a natural language processing library at some point, so\nlet's use the following for the example:\nobject NLPLib {\n  def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))\n}\n\nSuppose we manage to obtain a TypedDataFrame[PhoneBookEntry] and a TypedDataFrame[CityMapEntry] public data, here is what our Spark job could look like with frameless:\nimport org.apache.spark.sql.SQLContext\n\n// These case classes are used to hold intermediate results\ncase class Family(residents: String, neighborhood: Neighborhood)\ncase class Person(name: String, neighborhood: Neighborhood)\ncase class NeighborhoodCount(neighborhood: Neighborhood, count: Long)\n\ndef bestNeighborhood\n  (phoneBookTF: TypedDataFrame[PhoneBookEntry], cityMapTF: TypedDataFrame[CityMapEntry])\n  (implicit c: SQLContext): String = {\n                                          (((((((((\n  phoneBookTF\n    .innerJoin(cityMapTF).using('address) :TypedDataFrame[(Address, String, Double, String)])\n    .select('_2, '_4)                     :TypedDataFrame[(String, String)])\n    .as[Family]()                         :TypedDataFrame[Family])\n    .flatMap { f =>\n      f.residents.split(' ').map(r => Person(r, f.neighborhood))\n    }                                     :TypedDataFrame[Person])\n    .filter { p =>\n      NLPLib.uniqueName(p.name)\n    }                                     :TypedDataFrame[Person])\n    .groupBy('neighborhood).count()       :TypedDataFrame[(String, Long)])\n    .as[NeighborhoodCount]()              :TypedDataFrame[NeighborhoodCount])\n    .sortDesc('count)                     :TypedDataFrame[NeighborhoodCount])\n    .select('neighborhood)                :TypedDataFrame[Tuple1[String]])\n    .head._1\n}\n\nIf you compare this version from Spark vanilla where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.\nLimitations\nThe main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.\nIn the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.\n"}}}
\ No newline at end of file
diff --git a/docs/src/main/tut/README.md b/docs/src/main/tut/README.md
index adf343823..fef135d78 100644
--- a/docs/src/main/tut/README.md
+++ b/docs/src/main/tut/README.md
@@ -18,12 +18,13 @@ associated channels (e.g. GitHub, Gitter) to be a safe and friendly environment
 
 ## Documentation
 
-* [TypedDataset: Feature Overview](http://typelevel.github.io/frameless/docs/book/FeatureOverview.html)
-* [Comparing TypedDatasets with Spark's Datasets](http://typelevel.github.io/frameless/docs/book/TypedDatasetVsSparkDataset.html)
-* [Typed Encoders in Frameless](http://typelevel.github.io/frameless/docs/book/TypedEncoder.html)
-* [Injection: Creating Custom Encoders](http://typelevel.github.io/frameless/docs/book/Injection.html)
-* [Using Cats with RDDs](http://typelevel.github.io/frameless/docs/book/Cats.html)
-* [Proof of Concept: TypedDataFrame](http://typelevel.github.io/frameless/docs/book/TypedDataFrame.html)
+* [TypedDataset: Feature Overview](http://typelevel.org/frameless/FeatureOverview.html)
+* [Comparing TypedDatasets with Spark's Datasets](http://typelevel.org/frameless/TypedDatasetVsSparkDataset.html)
+* [Typed Encoders in Frameless](http://typelevel.org/frameless/TypedEncoder.html)
+* [Injection: Creating Custom Encoders](http://typelevel.org/frameless/Injection.html)
+* [Job\[A\]](http://typelevel.org/frameless/Job.html)
+* [Using Cats with RDDs](http://typelevel.org/frameless/Cats.html)
+* [Proof of Concept: TypedDataFrame](http://typelevel.org/frameless/TypedDataFrame.html)
 
 ## Why?
 
diff --git a/docs/book/gitbook/fonts/fontawesome/FontAwesome.otf b/gitbook/fonts/fontawesome/FontAwesome.otf
similarity index 100%
rename from docs/book/gitbook/fonts/fontawesome/FontAwesome.otf
rename to gitbook/fonts/fontawesome/FontAwesome.otf
diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.eot b/gitbook/fonts/fontawesome/fontawesome-webfont.eot
similarity index 100%
rename from docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.eot
rename to gitbook/fonts/fontawesome/fontawesome-webfont.eot
diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.svg b/gitbook/fonts/fontawesome/fontawesome-webfont.svg
similarity index 100%
rename from docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.svg
rename to gitbook/fonts/fontawesome/fontawesome-webfont.svg
diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.ttf b/gitbook/fonts/fontawesome/fontawesome-webfont.ttf
similarity index 100%
rename from docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.ttf
rename to gitbook/fonts/fontawesome/fontawesome-webfont.ttf
diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff b/gitbook/fonts/fontawesome/fontawesome-webfont.woff
similarity index 100%
rename from docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff
rename to gitbook/fonts/fontawesome/fontawesome-webfont.woff
diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff2 b/gitbook/fonts/fontawesome/fontawesome-webfont.woff2
similarity index 100%
rename from docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff2
rename to gitbook/fonts/fontawesome/fontawesome-webfont.woff2
diff --git a/docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js b/gitbook/gitbook-plugin-fontsettings/fontsettings.js
similarity index 100%
rename from docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js
rename to gitbook/gitbook-plugin-fontsettings/fontsettings.js
diff --git a/docs/book/gitbook/gitbook-plugin-fontsettings/website.css b/gitbook/gitbook-plugin-fontsettings/website.css
similarity index 100%
rename from docs/book/gitbook/gitbook-plugin-fontsettings/website.css
rename to gitbook/gitbook-plugin-fontsettings/website.css
diff --git a/docs/book/gitbook/gitbook-plugin-highlight/ebook.css b/gitbook/gitbook-plugin-highlight/ebook.css
similarity index 100%
rename from docs/book/gitbook/gitbook-plugin-highlight/ebook.css
rename to gitbook/gitbook-plugin-highlight/ebook.css
diff --git a/docs/book/gitbook/gitbook-plugin-highlight/website.css b/gitbook/gitbook-plugin-highlight/website.css
similarity index 100%
rename from docs/book/gitbook/gitbook-plugin-highlight/website.css
rename to gitbook/gitbook-plugin-highlight/website.css
diff --git a/docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js b/gitbook/gitbook-plugin-lunr/lunr.min.js
similarity index 100%
rename from docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js
rename to gitbook/gitbook-plugin-lunr/lunr.min.js
diff --git a/docs/book/gitbook/gitbook-plugin-lunr/search-lunr.js b/gitbook/gitbook-plugin-lunr/search-lunr.js
similarity index 100%
rename from docs/book/gitbook/gitbook-plugin-lunr/search-lunr.js
rename to gitbook/gitbook-plugin-lunr/search-lunr.js
diff --git a/docs/book/gitbook/gitbook-plugin-search/lunr.min.js b/gitbook/gitbook-plugin-search/lunr.min.js
similarity index 100%
rename from docs/book/gitbook/gitbook-plugin-search/lunr.min.js
rename to gitbook/gitbook-plugin-search/lunr.min.js
diff --git a/docs/book/gitbook/gitbook-plugin-search/search-engine.js b/gitbook/gitbook-plugin-search/search-engine.js
similarity index 100%
rename from docs/book/gitbook/gitbook-plugin-search/search-engine.js
rename to gitbook/gitbook-plugin-search/search-engine.js
diff --git a/docs/book/gitbook/gitbook-plugin-search/search.css b/gitbook/gitbook-plugin-search/search.css
similarity index 100%
rename from docs/book/gitbook/gitbook-plugin-search/search.css
rename to gitbook/gitbook-plugin-search/search.css
diff --git a/docs/book/gitbook/gitbook-plugin-search/search.js b/gitbook/gitbook-plugin-search/search.js
similarity index 100%
rename from docs/book/gitbook/gitbook-plugin-search/search.js
rename to gitbook/gitbook-plugin-search/search.js
diff --git a/docs/book/gitbook/gitbook-plugin-sharing/buttons.js b/gitbook/gitbook-plugin-sharing/buttons.js
similarity index 100%
rename from docs/book/gitbook/gitbook-plugin-sharing/buttons.js
rename to gitbook/gitbook-plugin-sharing/buttons.js
diff --git a/docs/book/gitbook/gitbook.js b/gitbook/gitbook.js
similarity index 100%
rename from docs/book/gitbook/gitbook.js
rename to gitbook/gitbook.js
diff --git a/docs/book/gitbook/images/apple-touch-icon-precomposed-152.png b/gitbook/images/apple-touch-icon-precomposed-152.png
similarity index 100%
rename from docs/book/gitbook/images/apple-touch-icon-precomposed-152.png
rename to gitbook/images/apple-touch-icon-precomposed-152.png
diff --git a/docs/book/gitbook/images/favicon.ico b/gitbook/images/favicon.ico
similarity index 100%
rename from docs/book/gitbook/images/favicon.ico
rename to gitbook/images/favicon.ico
diff --git a/docs/book/gitbook/style.css b/gitbook/style.css
similarity index 100%
rename from docs/book/gitbook/style.css
rename to gitbook/style.css
diff --git a/docs/book/gitbook/theme.js b/gitbook/theme.js
similarity index 100%
rename from docs/book/gitbook/theme.js
rename to gitbook/theme.js
diff --git a/docs/book/index.html b/index.html
similarity index 93%
rename from docs/book/index.html
rename to index.html
index df8113461..fc4d3d764 100644
--- a/docs/book/index.html
+++ b/index.html
@@ -252,12 +252,13 @@ 
                Frameless
                
 associated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning.
                
 
                Documentation
                
 
 
                Why?
                
 
                Benefits of using TypedDataset compared to the standard Spark Dataset API:
                
@@ -347,7 +348,7 @@ 
                No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Introduction","level":"1.1","depth":1,"next":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"path":"FeatureOverview.md","ref":"FeatureOverview.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"README.md","mtime":"2017-05-22T07:52:59.278Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-22T07:54:13.738Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Introduction","level":"1.1","depth":1,"next":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"path":"FeatureOverview.md","ref":"FeatureOverview.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"README.md","mtime":"2017-05-23T08:56:58.442Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-23T08:59:39.758Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/search_index.json b/search_index.json
new file mode 100644
index 000000000..1691f345f
--- /dev/null
+++ b/search_index.json
@@ -0,0 +1 @@
+{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["\"0.3.0\"","\"frameless","\"org.typelevel\"","%","%%","(e.g.","(includ","(peopl","(support","(thumb",")","++=","+1,","+=","0.13.13:","0.9.x)","2.0","2.0,","2.0.x)","2.11.x.","=",">=","add","adelbertc","against","apach","api:","are:","associ","avail","benefit","bootstrap","break","bring","build.sbt","built","cast","cat","cats\"","chang","channel","code","column","compar","compil","concept","concept:","conduct","consist","consol","contribut","contributor","creat","current","custom","customizable,","dataset","dataset\"","depend","develop","document","easi","encod","enhanc","environ","express","featur","few","file","file.","follow","frameless","framelessvers","framelessversion,","friendli","function","g8","get","giter8","github,","gitter)","ground,","http://opensource.org/licenses/apach","imario","imarios/frameless.g8","injection:","insid","instal","introduct","jeremyrsmith","job[a]","kanterov","learning.","librari","librarydepend","licens","list(","load","made","maintain","merg","modules:","more","needed:","new","next","non","note","olivierblanvillain","on","overview","possibl","project","project:","proof","provid","pull","quick","rdd","referenc","requests)","requests.","requir","resolv","resolver.sonatyperepo(\"releases\")","safe","same","sbt","scala","shell","sign","signatur","similar)","simply:","spark","spark'","spark).","spark.","standard","start","still","strongli","support","type","typeddatafram","typeddataset","typeddataset:","typelevel","types.","typesaf","under","up","up,","us","val","veri","versions.","want","way","well","why?","work"],"FeatureOverview.html":["\"false\")","\"paris\")","'`citi`'","'import","'name),","'population)","'price),","'project","(a)","(automated)","(b)","(enjoy","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(in","(lyon,166500.0))","(manual)","(name:","(paris,333333.3333333333),","(string,","(u:","(up","(which","(with",")",").as[aptpricecity].show().run",").as[stats].show().run()","*","+","...","/","//","1","10,","100,","10000.0,","102|","133000.0),","2","2).as[updatedsurface]","2).show().run()","2.0","200000.0),","2229621),","2229621|","2409.6385542168673,","25,","250000.0),","250|","25|[paris,","27|","2955.5555555555557,","300000.0),","325000.0)","343629)","343629|","4391.891891891892)","4391.891891891892|","45,","4500.0,","450000.0),","450|","458","47|","50,","500715),","500715|","500|","52|","6833.333333333333|","74,","740|","76|","83,","830|","85|",":27:",":28:",":31:",":33:",":34:",":36:","=","==","=>","['citi]","[1...10]).","[_1:","[city#206,","[city,","[city:","[lyon,45,133000.0]|","[lyon,500715]|","[lyon,83,200000.0]|","[nice,343629]|","[nice,74,325000.0]|","[paris,25,250000.0]|[paris,2229621]|","[paris,50,300000.0]|[paris,2229621]|","[ratio:","^","_1|","_2:","_2|","abov","achiev","actual","ad","addit","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","agg()","aggreg","aggregated,","agree.","align.","allcities:","allcities|","allow","allowed,","allowed.","alternatives:","and/or","anoth","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartmentdetail","apartmentdetails(city:","apartmentdetails?","api","appear","appli","aptd","aptds('price)","aptds('price)))","aptds('price),","aptds('surface))","aptds('surface)).as[apartmentdetails]","aptds('surface),","aptds.agg(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)).as[updatedsurface]","apttypedds('city),","apttypedds('city).cast[double]","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.join(citiinfotypedds,","apttypedds.makeudf(pricemodifier)","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds2","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","arguments)","as:","as[t]","avail","available.","averag","averageable:","avg(aptds('price)),","avg(aptds('surface)),","avgprice:","avgprice|","avgsurface:","avgsurface|minsurface|","base","better","between","boolean","boolean)].","c:","calcul","can't","case","case.","cast","cast,","catalystcast.","catalystcast[string,","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name))","city:","cityinfo","cityinfo(city:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|surface|","class","class:","claus","clause.","code","collectset(aptds('city))","column","column:","columns:","combin","compil","compile.","compile:","compiles:","complet","comput","computations.","conf","context","continu","correspond","creat","dataset","dataset.","dataset:","defin","detail","directli","discuss","divid","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","each","easili","elid","enabl","enabled.","entir","error","error.","error:","evid","exampl","example,","example.","exist","explan","explicitli","express","extra","featur","few","field","field]","fields]","find","five","follow","form","frameless","frameless.catalystaverageable[string,out]","frameless.catalystcast[string,double]","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.functions.aggregate._","frameless.implicits.widen._","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[apartment,double])(implicit","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","function","gener","get","give","given","groupbi","groupby()","here","here.","here:","however,","id","if(nam","implicit","implicitli","import","inform","initi","input","instanc","instances:","instanti","int","int)","int).","int,","int.","int]","interest","introduc","job","join","language:postfixops.","lazi","lazy.","let'","lift","localrel","long","look","lyon]|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","macro","make","materialize.","math","matter","member","method","method.","min(aptds('surface)),","minimum","minsurface:","misspel","mistak","more","n","n:","name","name:","need","new","next","next,","nice,","nice|","nice|325000.0|","not,","note","now","on","oper","operations:","option","order","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:58)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:77)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$8.apply(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2$1.apply(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionup$1(queryplan.scala:269)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:69)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:308)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:126)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:186)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:307)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:64)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2603)","org.apache.spark.sql.dataset.select(dataset.scala:969)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:49)","org.apache.spark.sql.sparksess","org.apache.spark.{sparkconf,","overload","overview","paramet","particular","per","perform","perhap","popul","population:","postfix","prefer","preserv","price","price#208]","price,","price/surfac","price:","price:double)","price];;","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.collect.run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","proce","project","prove","rais","ratio","ratio:","ratio|","readi","referenc","repl\").set(\"spark.ui.enabled\",","requir","res17:","res6:","res7:","resolv","result","retriev","right?","row","run","run()","safe","safe,","safe.","safety,","safety.","same","scala","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala.language.postfixop","scala.language.postfixops'","scaladoc","see","seem","select","select()","selectmany()","selectmany,","seq(","seq[(string,","seq[double]","set","shapeless.tag.tagged[string(\"citi\")]","shorter","show","show()","simpl","skip","spark","spark.createdataset(apartments)","spark.implicits._","spark.sparkcontext.setloglevel(\"warn\")","spark.sqlcontext","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","sqlcontext","stack","standard","start","stat","stats(","string","string)","string),updatedsurface]","string,","string]","struct,","struct]","subset","suggests,","support","suppos","surfac","surface#207,","surface,","surface,th","surface:","symbol","syntax:","t","tell","ten","three","time","time,","top","trace):","tri","tutori","two","type","type:","typedcolumn","typeddataset","typeddataset.","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","types,","typesaf","typo","u","udf","udf(aptds('city),","udf:","unit:","unlik","unsaf","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","val","valid","valu","vector[string])","visible.","want","warning:","way","wherea","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","work","worked,","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","|","|1000|102|","|276333.3333333333|62.833333333333336|","|4500.0|450000.0|","|6000.0|300000.0|","|[paris,100,450000.0]|[paris,2229621]|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|"],"TypedDatasetVsSparkDataset.html":["\"e\")","\"java.util.date\",","\"jday\")","\"mydate\"","\"q\")","\"w\")","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","&&","'`x`'","'project","(case","(class:","(i#69l","(int,","(isnotnull(i#69l)","(look","(see","(the",")",").explain()",").select(",").show().run()","*batchedscan","*deserializetoobject","*filter","*mapel","*project","*serializefromobject","+",",","...",".appli","//","10","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10|","1|","450","770",":20:",":21:",":22:","::","=","==","===","['x]","[],","[i#69l","[i#69l,j#70]","[i#69l]","[i,","[i:","[input[0,","[isnotnull(i),","^","_1#176l]","_1|","above.","access","achiev","act","ad","allow","api","applications.","area","argument","as[long]","assum","at[long]","avoid","bar","bar(1)))","bar(i:","before.","bigint","bigint))","bigint,","bigint]","bind","both","bug","bulletproof:","captur","case","cast","cast(10","catalyst","class","class:","classes)","clearli","closur","closures.","code","code.","column","columnar","columns,","columns:","compar","comparison,","compil","compromis","content","context","correct.","correctli","creat","current","dataset","dataset.","dataset[long].","datasets,","defin","detail.","detect","differ","discuss","discussion.","disk","doesn't","ds","ds.filter($\"i\"","ds.filter(_.i","ds.show()","ds:","each","elid","encod","encoder:","entir","equalto(i,10)],","error","error:","etc)","exampl","example,","exist","explain","explicitli","express","extrem","e|","fail","failure:","familiar","fd","fds('i)","fds('x)","fds.filter(","fds:","few","field","fields.","file","file.","file:/tmp/foo,","filter","filteredd","filteredds.explain()","filteredds.show()","filteredds:","find","first","first,","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo,","foo.","format","format:","found","frameless","frameless'","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[mydate]","friend.","fulli","function","futur","generated.","give","given","goal:","great!","guard","handhold","help","here","here.","hold","however,","implement","implicit","import","improv","incompat","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","input","inputpaths:","insid","int)","introduc","intuitively,","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date(system.currenttimemillis))))","java.util.date)","j|","know","last","lead","let'","limit","line","linux","load","long","long,","look","mac","map","member","members.","mention","mistak","more","mydat","mydate(jday:","name","name:","need","newinstance(class","next","nil","non","note","notifi","now,","obj#103:","obj#104:","ok","on","oper","optim","optimizer)","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:58)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:77)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:61)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$8.apply(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2$1.apply(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionup$1(queryplan.scala:269)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:592)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:598)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:425)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:69)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:308)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:126)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:186)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:307)","org.apache.spark.sql.dataset.(dataset.scala:161)","org.apache.spark.sql.dataset.(dataset.scala:167)","org.apache.spark.sql.dataset.select(dataset.scala:1023)","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:274)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:49)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:47)","os","paramet","parquet","parquetformat,","partial","partitionfilters:","pass","performance.","physic","plan","plan,","plan.","plan:","popular","practic","primit","problem","problem.","product","product,","provid","pushedfilters:","queri","quick","q|","read","readschema).","readschema:","refer","relation[i#69l,j#70]","releases.","remind","requir","resolv","return","root","run","runtim","safe","safe.","safety!","safety.","save","scala","scala.","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala>","schema","second,","see","select","select()","separately,","serial","serv","set","shapeless.tag.tagged[string(\"x\")]","show","simpl","simplist","slow","small","solut","solv","spark","spark'","spark.","spark.createdataset(","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark:","sparksess","standard","statement","statement).","store","string)","string,","string]","struct","subset","suffici","support","symbol","syntax","syntax.","take","thing","this.","time","time.","time:","togeth","tri","true]","tutori","two","type","type.","typedcolumn","typeddataset","typeddataset.","typeddataset.create(ds)","typeddataset.create(seq(mydate(new","typeddatset","unabl","unfortunately,","us","val","valu","value#105l]","veri","view","want","way","well","without","work","w|","x","x:","|","|100|","|value|"],"TypedEncoder.html":["\"daterange\"","\"java.util.date\",","\"s\")","\"s\"))))","\"s\",","(a","(and","(class:","...","//","2.0)","230",":26:",":28:","=","[i:","^","annoy","approach","around","b:","bar","bar(1.1,","bar(d:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","behav","besid","call","case","class","class:","classes.","code","compil","construct","coupl","current","custom","data","data.","dataset","dataset?.","dataset[daterange]","daterange(s:","decod","defin","deriv","derived,","detect","different,","double,","ds.collect()","ds:","e:","elid","encod","encoder.","encoder:","encoders,","ensur","error","error:","exampl","example,","existence)","expected:","extend","fail","field","find","follow","foo","foo(i:","foodate(i:","found","frameless","frameless.job$$anon$4@8a0bd3c","frameless.job[seq[foo]]","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless:","gener","goe","hierarchi","ident","implicit","implicitli","import","inabl","int,","intern","introduc","issues.","it'","java.lang.unsupportedoperationexception:","java.util.d","java.util.date)","java.util.date)))","java.util.date))))","java.util.date,","jvm","lead","limit","manipul","mechan","method","more","name:","new","non","note","object","onc","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:61)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:592)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:598)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:425)","org.apache.spark.sql.dataset","org.apache.spark.sql.encoders$.product(encoders.scala:274)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:47)","overflow","paramet","pass","performances.","prove","question","recurs","reflect","represent","res2:","resolut","root","run","runtim","s:","same","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala>","scalareflect","schema.","see","shapeless","shown","situat","solv","spark","spark.implicits._","spark:","sqlcontext.createdataset(seq(daterange(new","stack","standard","store","string)","string,","struct]","summari","support","t:","take","thought","time,","time.","time:","trace,","tri","type","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeencod","types.","us","val","valu","vanilla","won't","work"],"Injection.html":["$anon$1@6d6cc4bc","//","1","10:57:10","2","2017))","23","3",":24:",":32:","=","=>","[age:","^","a):","again","anoth","apply(a:","apply(d:","available,","b","b):","b.","b]","bigint]","birthday:","can't,","case","cest","class","class:","compil","creat","custom","d.gettime()","datetolonginject","datetolonginjection:","def","defin","definit","encod","encoder:","error.","error:","exampl","extend","family:","femal","find","frameless._","frameless.injection$$anon$1@70fdc07","frameless.injection$$anon$1@79ea3da5","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.typeddataset[person]","frameless.typedencoder[person]","function:","gender","gender)","gender:","gendertoint:","implicit","import","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","instanc","int,","int]","invert(b:","invert(l:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date)","java.util.date))","java.util.date).gettime(),","java.util.date):","java.util.date.","less","let","let'","list(person(42,male))","list(person(42,tu","long","long)))","long):","long:","long]","look","male","male))","more","new","now","object","on","paramet","peopl","people:","person","person(age:","persond","personds:","precis","seal","seq(person(42,","seq[person]","serializ","simpl","trait","tri","type","type,","typeclass:","typeddataset,","typeddataset.create(people)","typeddataset:","typedencod","us","val","valu","verbos","{","}","})","},"],"Job.html":["(a","(sample:","//","1","20%","20)","=","[_1:","above)","allow","along","annotate/nam","applic","be","block","calcul","collect","compar","complex","compos","composit","comprehens","comput","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","count","countandtakejob","def","description.","differ","driver","ds","ds:","easier","element","elements:","exactli","exampl","execut","expens","explicit","explicitli","few","finaljob","finaljob.","finaljob:","first","frameless.job","frameless.job$$anon$2@2e359e76","frameless.job[int]","frameless.job[seq[int]])frameless.job[int]","frameless.typeddataset[int]","functions:","further","group","have","help","id","import","inform","int","int]","issues.","job","job[a]","job[a],","job[int]","job[seq[int]]):","jobs.","lazi","lazili","lazy,","lazy.","make","min\").","monad","more","new","non","now","obviou","oper","part","pass","perform","place","predict","program","programm","provid","res2:","result","return","run","run()","sample.map(_.min)","say,","see","sequenc","serv","sever","show","showcas","size","spark","spark.","specifi","strict","toy","track","track,","transform","typeddataset","typeddataset.create(1","ui","us","val","via","withdescription(\"sampl","withgroupid(\"samplingjob\").","{"],"Cats.html":["\"task2\"","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(1,","(1,2,3)","(10,9,9)","(8,","(8,2,3)","(and","(chris,map(0","(john,map(0","(sam,map(0","(semigroup)",")","//","1","1)","1))","1)),","1),","1,","10))","10,","100)","11))","12)","12,","15)))","2","2)","2))","2)),","2,","20)","20,","3)","3))","3,","32,","4))","4)),","4,","5,","6,",":21",":22",":24",":26","::","=",">","aggreg","alia","alias","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","anna","arbitrari","arity.","array((joe,map(0","array[(username,","assum","avg,","below","cat","cats.implicits.","cats.implicits._","cats:","class","collect","column","combin","common","complex","comput","data","data.","data:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","default","defin","differ","element","etc.","exampl","example,","example:","execut","follow","frameless.cats.implicits._","frameless.cats.outer._","full","general).","group","implicit","implicits.scala:18","implicits.scala:43","import","int","int)]","int,","joe","join","key","key.","keys.","larg","leverag","makerdd","map(\"task1\"","map(\"task3\"","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[10]","mapvalu","max,","meaning","min,","more","nil","nil)","note","offer","on","oper","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","outer","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","pair","parallelcollectionrdd[0]","parallelcollectionrdd[1]","parallelcollectionrdd[3]","parallelcollectionrdd[5]","parallelcollectionrdd[6]","predicates.","previous","println(data.cmax)","println(data.cmin)","println(data.csum)","rdd","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","reducebykey","res10:","res11:","res7:","res8:","same","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala.collection.immutable.map[string,int])]","scala.collection.map[string,scala.collection.immutable.map[string,int]]","scala.collection.map[user,transactioncount]","section","semigroup","set","show","shuffledrdd[2]","shuffledrdd[4]","simplifi","sort","spark","string","task","task2","task3","timeseri","timeseries)]","together.","totalperus","totalperuser.collectasmap","totalperuser:","transactioncount","transactioncount)]","tupl","type","type.","us","user","user'","usernam","val","valu","way","work","|+|"],"TypedDataFrame.html":["\"dummy\"","\"unique\"","').map(r","'_4)","'q',","'s)","'x',","'z'))","'z'.","(((((((((","(implicit","(phonebooktf:",")",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","//","1.6","1.6+,","1.6,","11","2.10,","2.11","2.11,","22.",":",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","=>","???","addit","address","address,","address:","alphabet:","alternatively,","amount","api","approach","approxim","ariti","avail","away:","b:","bar(i:","be","bestneighborhood","boolean","boolean)","boolean):","boolean)]","boolean,","both","bring","c:","call","case","catch","caus","citi","citymapentry(","citymaptf:","class","column","columns.","come","common","commonli","compar","compat","compil","complet","comput","concept:","consid","consist","contain","conveni","correct","cough","count:","d:","data,","datafram","dataframe,","dataframes,","dataset","def","defin","definit","deprec","design","develop","differ","directli","dive","documented.","domain","done","doubl","double,","due","each","earli","element","enough","ensur","essenti","everyth","exampl","example:","except","execut","exist","expect","f","f.neighborhood))","f.residents.split('","fact","family(residents:","field","filter(conditionexpr:","first","flat","focu","follow","foo(s:","frameless","frameless.","frameless.typeddatafram","frameless:","function","further","futur","get","go","goal","goe","handl","have","here","hold","however,","i:","ident","import","improv","inform","instead","int)","int,","interest","intermedi","introduc","introduct","j:","job","jobs.","join","join1(tf1:","join2(tf1:","joins,","keep","languag","less","let","let'","letter","level","leverag","librari","like,","limit","limitations.","line","long)","long)])","look","main","manag","manipul","manner.","map","mirror","mistak","model","moder","more","much","name","name.exists(set('x',","names,","natur","need","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","nlplib","nlplib.uniquename(p.name)","now","number,","object","obtain","ontypeddataframe.","onward.","org.apache.spark.sql.datafram","org.apache.spark.sql.sqlcontext","p","packag","pair","person(name:","person(r,","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","point,","possibl","process","product.","proof","provid","public","readability.","readabl","reasons,","refer","referenc","represent","residents:","result","rethought","return","right","sadly,","safe","safety.","scala","schema","schema.","second","see","see,","seem","select","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","shadow","shapeless.hlist","signatures:","similar","simplifi","singl","spark","spark'","spark,","sqlcontext):","stage","still","store","string","string):","string)]","string)])","string,","suppos","syntax","syntaxes,","system","systems,","tabl","table,","tables:","target","tdataframe[schema","tdataframe[schema]","techniqu","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","time.","track","troubl","tuple23","two","type","type,","type.","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry]","typeddataframe[citymapentry])","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","types:","typo,","uniqu","uniquename(name:","us","user","valu","vanilla","variou","veri","version","way","well,","won't","work","zero.","{","}"]},"length":8},"tokenStore":{"root":{"0":{"docs":{},".":{"1":{"3":{"docs":{},".":{"1":{"3":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"docs":{}},"docs":{}}},"docs":{}},"9":{"docs":{},".":{"docs":{},"x":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}},"docs":{}}},"1":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"i":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}},":":{"5":{"7":{"docs":{},":":{"1":{"0":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.017391304347826087}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.013043478260869565}}},".":{"6":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"+":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"docs":{}}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"1":{"7":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"docs":{}},"docs":{},"%":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"3":{"0":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"4":{"0":{"9":{"docs":{},".":{"6":{"3":{"8":{"5":{"5":{"4":{"2":{"1":{"6":{"8":{"6":{"7":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"9":{"5":{"5":{"docs":{},".":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},".":{"docs":{},"x":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"1":{"0":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{},"x":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"docs":{}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}}}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"4":{"3":{"6":{"2":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"4":{"3":{"9":{"1":{"docs":{},".":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"8":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"6":{"8":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"7":{"4":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"7":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"docs":{}},"docs":{}},"8":{"3":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{},"\"":{"0":{"docs":{},".":{"3":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"docs":{}}},"docs":{}}},"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"q":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"w":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"y":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"2":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"docs":{}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"%":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}},"%":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}}},"(":{"1":{"0":{"docs":{},",":{"9":{"docs":{},",":{"9":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}},"docs":{}}},"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"8":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"y":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}},"t":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"#":{"6":{"9":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}},"docs":{}},"docs":{}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"6":{"9":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}},"e":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"b":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"1":{"6":{"6":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"u":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}}}},"\"":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}}}}},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}}}}},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}}},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}},"+":{"1":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0622906898861353},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.04267589388696655}},"+":{"docs":{},"=":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"=":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"=":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.03415941058271936},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01384083044982699},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.024922118380062305},"Injection.html":{"ref":"Injection.html","tf":0.06349206349206349},"Job.html":{"ref":"Job.html","tf":0.040229885057471264},"Cats.html":{"ref":"Cats.html","tf":0.05217391304347826},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.016605166051660517}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.011534025374855825}},"=":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495}}}},">":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}},">":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.08695652173913043}},"=":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"e":{"docs":{},"l":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"d":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}},"s":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"3":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"(":{"docs":{},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"[":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},"e":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"b":{"docs":{},"o":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Job.html":{"ref":"Job.html","tf":0.017241379310344827}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"n":{"docs":{},"o":{"docs":{},"y":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"t":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"b":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"docs":{}}},"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"(":{"1":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"docs":{}},"docs":{}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007367716008037508},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.024922118380062305},"Injection.html":{"ref":"Injection.html","tf":0.04126984126984127},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01845018450184502}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.018604651162790697},"Cats.html":{"ref":"Cats.html","tf":3.339855072463768}},"s":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"u":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012915129151291513}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.502306805074971},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"x":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}}}}}},"o":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351783517835174}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"o":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Injection.html":{"ref":"Injection.html","tf":2.5126984126984127}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":2.503174603174603}},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.010716677829872739},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010380622837370242},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03426791277258567},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.02214022140221402}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"u":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.018604651162790697},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5092272202998847},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"\"":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"?":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012915129151291513}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}}}}}}}}},"y":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"f":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014760147601476014}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.03492063492063492},"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018691588785046728}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"e":{"docs":{},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"_":{"docs":{},".":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.021806853582554516},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"u":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.013953488372093023},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3551401869158877},"Injection.html":{"ref":"Injection.html","tf":2.5126984126984127}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"s":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"t":{"docs":{},"i":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"s":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"i":{"docs":{},",":{"1":{"0":{"docs":{},")":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"docs":{}},"docs":{}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.334672918062067}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}},":":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}}},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},"a":{"docs":{},"l":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"c":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.04186046511627907},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3426791277258565},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}}}}}}}}}}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"7":{"0":{"docs":{},"f":{"docs":{},"d":{"docs":{},"c":{"0":{"7":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"docs":{}},"docs":{}}}}},"9":{"docs":{},"e":{"docs":{},"a":{"3":{"docs":{},"d":{"docs":{},"a":{"5":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"docs":{}}}},"docs":{}}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"2":{"docs":{},"@":{"2":{"docs":{},"e":{"3":{"5":{"9":{"docs":{},"e":{"7":{"6":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"4":{"docs":{},"@":{"8":{"docs":{},"a":{"0":{"docs":{},"b":{"docs":{},"d":{"3":{"docs":{},"c":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"_":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}}}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"s":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495}}}},"x":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"l":{"docs":{},")":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015873015873015872}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}}},"t":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"8":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},"docs":{}}},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"p":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"b":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}},"o":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"a":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"l":{"docs":{},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"v":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"s":{"docs":{},"/":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}},"docs":{}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152},"Injection.html":{"ref":"Injection.html","tf":0.015873015873015872},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"docs":{}},"4":{"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}},"docs":{}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008707300736771601},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.017391304347826087},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015873015873015872}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"Injection.html":{"ref":"Injection.html","tf":2.503174603174603}}},"(":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},"n":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"t":{"docs":{"./":{"ref":"./","tf":10},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"l":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"f":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"t":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"j":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"y":{"docs":{},"r":{"docs":{},"s":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.022988505747126436},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"Job.html":{"ref":"Job.html","tf":10.005747126436782}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"n":{"1":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}}}}},"2":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01107011070110701}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"l":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.01557632398753894}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"v":{"docs":{},"m":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"e":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"s":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}}}}},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.018604651162790697}}}}}},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}},"t":{"docs":{},"u":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"docs":{}},"docs":{}}}}}}}}}}},"f":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"u":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"o":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},":":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"y":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"r":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"8":{"2":{"docs":{},".":{"5":{"9":{"7":{"0":{"5":{"4":{"8":{"8":{"6":{"2":{"1":{"1":{"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"m":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"r":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"Job.html":{"ref":"Job.html","tf":0.022988505747126436}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.013043478260869565}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}},"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}},"3":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"docs":{}}}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"0":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"n":{"docs":{},"i":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"e":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"x":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"e":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007367716008037508},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"a":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"u":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"e":{"docs":{},"(":{"docs":{},"j":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018691588785046728},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}},"x":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"t":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"v":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}}}}}}}}}}},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"c":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3340031256977003}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Job.html":{"ref":"Job.html","tf":0.028735632183908046},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00922722029988466}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"$":{"2":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"7":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"8":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"2":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"2":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"$":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"0":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"0":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"9":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"8":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"9":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"8":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"9":{"8":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"$":{"docs":{},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"$":{"docs":{},"$":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"0":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"2":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}},"9":{"6":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"6":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"$":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"{":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},".":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"j":{"docs":{},"#":{"1":{"0":{"3":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.018604651162790697},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"o":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351783517835174}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}},"#":{"2":{"0":{"8":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"/":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"b":{"docs":{},"y":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"3":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"1":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"3":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"5":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"6":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"i":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.012687427912341407}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"i":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"s":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}},"(":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905}},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"t":{"docs":{},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"c":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"Cats.html":{"ref":"Cats.html","tf":3.3376811594202898}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"i":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}},"s":{"1":{"0":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"1":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"2":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"8":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"a":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"u":{"docs":{},"i":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"#":{"6":{"9":{"docs":{},"l":{"docs":{},",":{"docs":{},"j":{"docs":{},"#":{"7":{"0":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}},"o":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"m":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"y":{"docs":{},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"d":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.018604651162790697}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"5":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"9":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"s":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},">":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"2":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"4":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"y":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"z":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.018604651162790697},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01384083044982699},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Job.html":{"ref":"Job.html","tf":0.034482758620689655},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01845018450184502}},"'":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5046136101499425},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},")":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"[":{"docs":{},"*":{"docs":{},"]":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"g":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},",":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.014735432016075016},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014760147601476014}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"#":{"2":{"0":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007367716008037508}}}}}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"[":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.017241379310344827}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"i":{"docs":{},"z":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.018604651162790697},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.010046885465505693},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0196078431372549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Cats.html":{"ref":"Cats.html","tf":0.02391304347826087},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.027675276752767528}},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.34440344403444}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"p":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5034602076124566},"Job.html":{"ref":"Job.html","tf":0.022988505747126436}},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3353427104264344},"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"docs":{}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905}}}}}}}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"[":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}},"u":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"a":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.013953488372093023},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}}}},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"u":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"p":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"2":{"3":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"docs":{}},"docs":{}}}}},"w":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{},"k":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}},"f":{"1":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"j":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"2":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"j":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"i":{"docs":{},"t":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}}},"p":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{"./":{"ref":"./","tf":0.027906976744186046},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"Job.html":{"ref":"Job.html","tf":0.017241379310344827},"Cats.html":{"ref":"Cats.html","tf":3.339855072463768},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.00922509225092251}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"'":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}},"d":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.018754186202277295},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018691588785046728},"Injection.html":{"ref":"Injection.html","tf":0.03492063492063492},"Job.html":{"ref":"Job.html","tf":0.017241379310344827},"Cats.html":{"ref":"Cats.html","tf":0.017391304347826087}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},"#":{"1":{"0":{"5":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"docs":{}},"docs":{}},"docs":{}}}}},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"a":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"y":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"h":{"docs":{},"y":{"docs":{},"?":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"(":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"'":{"docs":{},"`":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"x":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"_":{"4":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"q":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"z":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"*":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"b":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006028131279303416},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"_":{"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"docs":{}}}}}}},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.12391158740790355},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.08419838523644751},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.06666666666666667},"Job.html":{"ref":"Job.html","tf":0.028735632183908046},"Cats.html":{"ref":"Cats.html","tf":0.05},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},":":{"2":{"0":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"4":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"6":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"3":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"2":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"4":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Cats.html":{"ref":"Cats.html","tf":0.0391304347826087}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"[":{"1":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"1":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"docs":{}},"docs":{}}}}},"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"x":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"_":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"docs":{}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"#":{"2":{"0":{"6":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006697923643670462}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"4":{"5":{"docs":{},",":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"8":{"3":{"docs":{},",":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"4":{"3":{"6":{"2":{"9":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"7":{"4":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"5":{"docs":{},",":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"5":{"0":{"docs":{},",":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}},"i":{"docs":{},"#":{"6":{"9":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},",":{"docs":{},"j":{"docs":{},"#":{"7":{"0":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"[":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}}}}}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}},"^":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008037508372404554},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},"_":{"1":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"#":{"1":{"7":{"6":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"docs":{}},"docs":{}},"docs":{}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}},"docs":{}},"|":{"1":{"0":{"0":{"0":{"docs":{},"|":{"1":{"0":{"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"2":{"7":{"6":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"6":{"2":{"docs":{},".":{"8":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.01808439383791025},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00922722029988466}},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"1":{"0":{"0":{"docs":{},",":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"+":{"docs":{},"|":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}}},"$":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"1":{"4":{"docs":{},".":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"6":{"docs":{},"d":{"6":{"docs":{},"c":{"docs":{},"c":{"4":{"docs":{},"b":{"docs":{},"c":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"docs":{}}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}},"&":{"docs":{},"&":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"{":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},"}":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"?":{"docs":{},"?":{"docs":{},"?":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"length":2211},"corpusTokens":["\"0.3.0\"","\"daterange\"","\"dummy\"","\"e\")","\"false\")","\"frameless","\"java.util.date\",","\"jday\")","\"mydate\"","\"org.typelevel\"","\"paris\")","\"q\")","\"s\")","\"s\"))))","\"s\",","\"task2\"","\"unique\"","\"w\")","$anon$1@6d6cc4bc","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","%","%%","&&","').map(r","'_4)","'`citi`'","'`x`'","'import","'name),","'population)","'price),","'project","'q',","'s)","'x',","'z'))","'z'.","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(((((((((","(1,","(1,2,3)","(10,9,9)","(8,","(8,2,3)","(a","(a)","(and","(automated)","(b)","(case","(chris,map(0","(class:","(e.g.","(enjoy","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(i#69l","(implicit","(in","(includ","(int,","(isnotnull(i#69l)","(john,map(0","(look","(lyon,166500.0))","(manual)","(name:","(paris,333333.3333333333),","(peopl","(phonebooktf:","(sam,map(0","(sample:","(see","(semigroup)","(string,","(support","(the","(thumb","(u:","(up","(which","(with",")",").as[aptpricecity].show().run",").as[stats].show().run()",").explain()",").select(",").show().run()","*","*batchedscan","*deserializetoobject","*filter","*mapel","*project","*serializefromobject","+","++=","+1,","+=",",","...",".appli",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","/","//","0.13.13:","0.9.x)","1","1)","1))","1)),","1),","1,","1.6","1.6+,","1.6,","10","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10,","100)","100,","10000.0,","102|","10:57:10","10|","11","11))","12)","12,","133000.0),","15)))","1|","2","2)","2))","2)),","2).as[updatedsurface]","2).show().run()","2,","2.0","2.0)","2.0,","2.0.x)","2.10,","2.11","2.11,","2.11.x.","20%","20)","20,","200000.0),","2017))","22.","2229621),","2229621|","23","230","2409.6385542168673,","25,","250000.0),","250|","25|[paris,","27|","2955.5555555555557,","3","3)","3))","3,","300000.0),","32,","325000.0)","343629)","343629|","4))","4)),","4,","4391.891891891892)","4391.891891891892|","45,","450","4500.0,","450000.0),","450|","458","47|","5,","50,","500715),","500715|","500|","52|","6,","6833.333333333333|","74,","740|","76|","770","83,","830|","85|",":",":20:",":21",":21:",":22",":22:",":24",":24:",":26",":26:",":27:",":28:",":31:",":32:",":33:",":34:",":36:","::",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","==","===","=>",">",">=","???","['citi]","['x]","[1...10]).","[],","[_1:","[age:","[city#206,","[city,","[city:","[i#69l","[i#69l,j#70]","[i#69l]","[i,","[i:","[input[0,","[isnotnull(i),","[lyon,45,133000.0]|","[lyon,500715]|","[lyon,83,200000.0]|","[nice,343629]|","[nice,74,325000.0]|","[paris,25,250000.0]|[paris,2229621]|","[paris,50,300000.0]|[paris,2229621]|","[ratio:","^","_1#176l]","_1|","_2:","_2|","a):","abov","above)","above.","access","achiev","act","actual","ad","add","addit","address","address,","address:","adelbertc","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","against","agg()","aggreg","aggregated,","agree.","alia","alias","align.","allcities:","allcities|","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","allowed,","allowed.","along","alphabet:","alternatively,","alternatives:","amount","and/or","anna","annotate/nam","annoy","anoth","apach","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartmentdetail","apartmentdetails(city:","apartmentdetails?","api","api:","appear","appli","applic","applications.","apply(a:","apply(d:","approach","approxim","aptd","aptds('price)","aptds('price)))","aptds('price),","aptds('surface))","aptds('surface)).as[apartmentdetails]","aptds('surface),","aptds.agg(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)).as[updatedsurface]","apttypedds('city),","apttypedds('city).cast[double]","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.join(citiinfotypedds,","apttypedds.makeudf(pricemodifier)","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds2","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","are:","area","argument","arguments)","ariti","arity.","around","array((joe,map(0","array[(username,","as:","as[long]","as[t]","associ","assum","at[long]","avail","available,","available.","averag","averageable:","avg(aptds('price)),","avg(aptds('surface)),","avg,","avgprice:","avgprice|","avgsurface:","avgsurface|minsurface|","avoid","away:","b","b):","b.","b:","b]","bar","bar(1)))","bar(1.1,","bar(d:","bar(i:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","before.","behav","below","benefit","besid","bestneighborhood","better","between","bigint","bigint))","bigint,","bigint]","bind","birthday:","block","boolean","boolean)","boolean):","boolean)]","boolean)].","boolean,","bootstrap","both","break","bring","bug","build.sbt","built","bulletproof:","c:","calcul","call","can't","can't,","captur","case","case.","cast","cast(10","cast,","cat","catalyst","catalystcast.","catalystcast[string,","catch","cats\"","cats.implicits.","cats.implicits._","cats:","caus","cest","chang","channel","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name))","city:","cityinfo","cityinfo(city:","citymapentry(","citymaptf:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|surface|","class","class:","classes)","classes.","claus","clause.","clearli","closur","closures.","code","code.","collect","collectset(aptds('city))","column","column:","columnar","columns,","columns.","columns:","combin","come","common","commonli","compar","comparison,","compat","compil","compile.","compile:","compiles:","complet","complex","compos","composit","comprehens","compromis","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","concept","concept:","conduct","conf","consid","consist","consol","construct","contain","content","context","continu","contribut","contributor","conveni","correct","correct.","correctli","correspond","cough","count","count:","countandtakejob","coupl","creat","current","custom","customizable,","d.gettime()","d:","data","data,","data.","data:","datafram","dataframe,","dataframes,","dataset","dataset\"","dataset.","dataset:","dataset?.","dataset[daterange]","dataset[long].","datasets,","daterange(s:","datetolonginject","datetolonginjection:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","decod","def","default","defin","definit","depend","deprec","deriv","derived,","description.","design","detail","detail.","detect","develop","differ","different,","directli","discuss","discussion.","disk","dive","divid","document","documented.","doesn't","domain","done","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","ds","ds.collect()","ds.filter($\"i\"","ds.filter(_.i","ds.show()","ds:","due","e:","each","earli","easi","easier","easili","element","elements:","elid","enabl","enabled.","encod","encoder.","encoder:","encoders,","enhanc","enough","ensur","entir","environ","equalto(i,10)],","error","error.","error:","essenti","etc)","etc.","everyth","evid","exactli","exampl","example,","example.","example:","except","execut","exist","existence)","expect","expected:","expens","explain","explan","explicit","explicitli","express","extend","extra","extrem","e|","f","f.neighborhood))","f.residents.split('","fact","fail","failure:","familiar","family(residents:","family:","fd","fds('i)","fds('x)","fds.filter(","fds:","featur","femal","few","field","field]","fields.","fields]","file","file.","file:/tmp/foo,","filter","filter(conditionexpr:","filteredd","filteredds.explain()","filteredds.show()","filteredds:","finaljob","finaljob.","finaljob:","find","first","first,","five","flat","focu","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo(s:","foo,","foo.","foodate(i:","form","format","format:","found","frameless","frameless'","frameless.","frameless._","frameless.catalystaverageable[string,out]","frameless.catalystcast[string,double]","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.cats.implicits._","frameless.cats.outer._","frameless.functions.aggregate._","frameless.implicits.widen._","frameless.injection$$anon$1@70fdc07","frameless.injection$$anon$1@79ea3da5","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.job","frameless.job$$anon$2@2e359e76","frameless.job$$anon$4@8a0bd3c","frameless.job[int]","frameless.job[seq[foo]]","frameless.job[seq[int]])frameless.job[int]","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[apartment,double])(implicit","frameless.typeddatafram","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[foo]","frameless.typeddataset[int]","frameless.typeddataset[person]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless.typedencoder[mydate]","frameless.typedencoder[person]","frameless:","framelessvers","framelessversion,","friend.","friendli","full","fulli","function","function:","functions:","further","futur","g8","gender","gender)","gender:","gendertoint:","gener","general).","generated.","get","giter8","github,","gitter)","give","given","go","goal","goal:","goe","great!","ground,","group","groupbi","groupby()","guard","handhold","handl","have","help","here","here.","here:","hierarchi","hold","however,","http://opensource.org/licenses/apach","i:","id","ident","if(nam","imario","imarios/frameless.g8","implement","implicit","implicitli","implicits.scala:18","implicits.scala:43","import","improv","inabl","incompat","inform","initi","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","input","inputpaths:","insid","instal","instanc","instances:","instanti","instead","int","int)","int).","int)]","int,","int.","int]","interest","intermedi","intern","introduc","introduct","intuitively,","invert(b:","invert(l:","issues.","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date(system.currenttimemillis))))","java.util.date)","java.util.date))","java.util.date)))","java.util.date))))","java.util.date).gettime(),","java.util.date):","java.util.date,","java.util.date.","jeremyrsmith","job","job[a]","job[a],","job[int]","job[seq[int]]):","jobs.","joe","join","join1(tf1:","join2(tf1:","joins,","jvm","j|","kanterov","keep","key","key.","keys.","know","languag","language:postfixops.","larg","last","lazi","lazili","lazy,","lazy.","lead","learning.","less","let","let'","letter","level","leverag","librari","librarydepend","licens","lift","like,","limit","limitations.","line","linux","list(","list(person(42,male))","list(person(42,tu","load","localrel","long","long)","long)))","long):","long)])","long,","long:","long]","look","lyon]|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","mac","macro","made","main","maintain","make","makerdd","male","male))","manag","manipul","manner.","map","map(\"task1\"","map(\"task3\"","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[10]","mapvalu","materialize.","math","matter","max,","meaning","mechan","member","members.","mention","merg","method","method.","min\").","min(aptds('surface)),","min,","minimum","minsurface:","mirror","misspel","mistak","model","moder","modules:","monad","more","much","mydat","mydate(jday:","n","n:","name","name.exists(set('x',","name:","names,","natur","need","needed:","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","new","newinstance(class","next","next,","nice,","nice|","nice|325000.0|","nil","nil)","nlplib","nlplib.uniquename(p.name)","non","not,","note","notifi","now","now,","number,","obj#103:","obj#104:","object","obtain","obviou","offer","ok","olivierblanvillain","on","onc","ontypeddataframe.","onward.","oper","operations:","optim","optimizer)","option","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:58)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:77)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:61)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$8.apply(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2$1.apply(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionup$1(queryplan.scala:269)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:592)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:598)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:425)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:69)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:308)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:126)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:186)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:307)","org.apache.spark.sql.datafram","org.apache.spark.sql.dataset","org.apache.spark.sql.dataset$.ofrows(dataset.scala:64)","org.apache.spark.sql.dataset.(dataset.scala:161)","org.apache.spark.sql.dataset.(dataset.scala:167)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2603)","org.apache.spark.sql.dataset.select(dataset.scala:1023)","org.apache.spark.sql.dataset.select(dataset.scala:969)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:274)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:49)","org.apache.spark.sql.sparksess","org.apache.spark.sql.sqlcontext","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:47)","org.apache.spark.{sparkconf,","os","outer","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","overflow","overload","overview","p","packag","pair","parallelcollectionrdd[0]","parallelcollectionrdd[1]","parallelcollectionrdd[3]","parallelcollectionrdd[5]","parallelcollectionrdd[6]","paramet","parquet","parquetformat,","part","partial","particular","partitionfilters:","pass","peopl","people:","per","perform","performance.","performances.","perhap","person","person(age:","person(name:","person(r,","persond","personds:","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","physic","place","plan","plan,","plan.","plan:","point,","popul","popular","population:","possibl","postfix","practic","precis","predicates.","predict","prefer","preserv","previous","price","price#208]","price,","price/surfac","price:","price:double)","price];;","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.collect.run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","primit","println(data.cmax)","println(data.cmin)","println(data.csum)","problem","problem.","proce","process","product","product,","product.","program","programm","project","project:","proof","prove","provid","public","pull","pushedfilters:","queri","question","quick","q|","rais","ratio","ratio:","ratio|","rdd","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","read","readability.","readabl","readi","readschema).","readschema:","reasons,","recurs","reducebykey","refer","referenc","reflect","relation[i#69l,j#70]","releases.","remind","repl\").set(\"spark.ui.enabled\",","represent","requests)","requests.","requir","res10:","res11:","res17:","res2:","res6:","res7:","res8:","residents:","resolut","resolv","resolver.sonatyperepo(\"releases\")","result","rethought","retriev","return","right","right?","root","row","run","run()","runtim","s:","sadly,","safe","safe,","safe.","safety!","safety,","safety.","same","sample.map(_.min)","save","say,","sbt","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala","scala.","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.immutable.map[string,int])]","scala.collection.map[string,scala.collection.immutable.map[string,int]]","scala.collection.map[user,transactioncount]","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala.language.postfixop","scala.language.postfixops'","scala>","scaladoc","scalareflect","schema","schema.","seal","second","second,","section","see","see,","seem","select","select()","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","selectmany()","selectmany,","semigroup","separately,","seq(","seq(person(42,","seq[(string,","seq[double]","seq[person]","sequenc","serial","serializ","serv","set","sever","shadow","shapeless","shapeless.hlist","shapeless.tag.tagged[string(\"citi\")]","shapeless.tag.tagged[string(\"x\")]","shell","shorter","show","show()","showcas","shown","shuffledrdd[2]","shuffledrdd[4]","sign","signatur","signatures:","similar","similar)","simpl","simplifi","simplist","simply:","singl","situat","size","skip","slow","small","solut","solv","sort","spark","spark'","spark).","spark,","spark.","spark.createdataset(","spark.createdataset(apartments)","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark.sparkcontext.setloglevel(\"warn\")","spark.sqlcontext","spark:","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparksess","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","sqlcontext","sqlcontext):","sqlcontext.createdataset(seq(daterange(new","stack","stage","standard","start","stat","statement","statement).","stats(","still","store","strict","string","string)","string),updatedsurface]","string):","string)]","string)])","string,","string]","strongli","struct","struct,","struct]","subset","suffici","suggests,","summari","support","suppos","surfac","surface#207,","surface,","surface,th","surface:","symbol","syntax","syntax.","syntax:","syntaxes,","system","systems,","t","t:","tabl","table,","tables:","take","target","task","task2","task3","tdataframe[schema","tdataframe[schema]","techniqu","tell","ten","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","thing","this.","thought","three","time","time,","time.","time:","timeseri","timeseries)]","togeth","together.","top","totalperus","totalperuser.collectasmap","totalperuser:","toy","trace):","trace,","track","track,","trait","transactioncount","transactioncount)]","transform","tri","troubl","true]","tupl","tuple23","tutori","two","type","type,","type.","type:","typeclass:","typedcolumn","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry]","typeddataframe[citymapentry])","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","typeddataset","typeddataset,","typeddataset.","typeddataset.create(1","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset.create(ds)","typeddataset.create(people)","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset.create(seq(mydate(new","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","typeddatset","typedencod","typeencod","typelevel","types,","types.","types:","typesaf","typo","typo,","u","udf","udf(aptds('city),","udf:","ui","unabl","under","unfortunately,","uniqu","uniquename(name:","unit:","unlik","unsaf","up","up,","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","user'","usernam","val","valid","valu","value#105l]","vanilla","variou","vector[string])","verbos","veri","version","versions.","via","view","visible.","want","warning:","way","well","well,","wherea","why?","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withdescription(\"sampl","withgroupid(\"samplingjob\").","without","won't","work","worked,","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","w|","x","x:","zero.","{","|","|+|","|1000|102|","|100|","|276333.3333333333|62.833333333333336|","|4500.0|450000.0|","|6000.0|300000.0|","|[paris,100,450000.0]|[paris,2229621]|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|value|","}","})","},"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"Introduction","keywords":"","body":"Frameless\n\n\n\n\nFrameless is a proof-of-concept library for working with Spark using more expressive types.\nIt consists of the following modules:\n\ndataset for more strongly typed Datasets  (supports Spark 2.0.x)\ncats for using Spark with cats (supports Cats 0.9.x)\n\nThe Frameless project and contributors support the\nTypelevel Code of Conduct and want all its\nassociated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning.\nDocumentation\n\nTypedDataset: Feature Overview\nComparing TypedDatasets with Spark's Datasets\nTyped Encoders in Frameless\nInjection: Creating Custom Encoders\nJob[A]\nUsing Cats with RDDs\nProof of Concept: TypedDataFrame\n\nWhy?\nBenefits of using TypedDataset compared to the standard Spark Dataset API:\n\nTypesafe columns referencing and expressions\nCustomizable, typesafe encoders\nTypesafe casting and projections\nEnhanced type signature for some built-in functions\n\nQuick Start\nFrameless is compiled against Scala 2.11.x.\nNote that while Frameless is still getting off the ground, it is very possible that breaking changes will be\nmade for at least the next few versions.\nTo use Frameless in your project add the following in your build.sbt file as needed:\nresolvers += Resolver.sonatypeRepo(\"releases\")\n\nval framelessVersion = \"0.3.0\"\n\nlibraryDependencies ++= List(\n  \"org.typelevel\" %% \"frameless-cats\"      % framelessVersion,\n  \"org.typelevel\" %% \"frameless-dataset\"   % framelessVersion\n)\n\nAn easy way to bootstrap a Frameless sbt project:\n\nif you have Giter8 installed then simply:\n\ng8 imarios/frameless.g8\n\n\nwith sbt >= 0.13.13:\n\nsbt new imarios/frameless.g8\n\nTyping sbt console inside your project will bring up a shell with Frameless\nand all its dependencies loaded (including Spark).\nDevelopment\nWe require at least one sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers\n(people who can merge pull requests) are:\n\nadelbertc\nimarios\njeremyrsmith\nkanterov\nnon\nOlivierBlanvillain\n\nLicense\nCode is provided under the Apache 2.0 license available at http://opensource.org/licenses/Apache-2.0,\nas well as in the LICENSE file. This is the same license used as Spark.\n"},"FeatureOverview.html":{"url":"FeatureOverview.html","title":"TypedDataset: Feature Overview","keywords":"","body":"TypedDataset: Feature Overview\nThis tutorial introduces TypedDataset using a simple example.\nThe following imports are needed to make all code examples compile.\nimport org.apache.spark.{SparkConf, SparkContext}\nimport org.apache.spark.sql.SparkSession\nimport frameless.functions.aggregate._\nimport frameless.TypedDataset\n\nval conf = new SparkConf().setMaster(\"local[*]\").setAppName(\"frameless repl\").set(\"spark.ui.enabled\", \"false\")\nval spark = SparkSession.builder().config(conf).appName(\"REPL\").getOrCreate()\nimplicit val sqlContext = spark.sqlContext\nspark.sparkContext.setLogLevel(\"WARN\")\n\nimport spark.implicits._\n\nCreating TypedDataset instances\nWe start by defining a case class:\ncase class Apartment(city: String, surface: Int, price: Double)\n\nAnd few Apartment instances:\nval apartments = Seq(\n  Apartment(\"Paris\", 50, 300000.0),\n  Apartment(\"Paris\", 100, 450000.0),\n  Apartment(\"Paris\", 25, 250000.0),\n  Apartment(\"Lyon\", 83, 200000.0),\n  Apartment(\"Lyon\", 45, 133000.0),\n  Apartment(\"Nice\", 74, 325000.0)\n)\n\nWe are now ready to instantiate a TypedDataset[Apartment]:\nval aptTypedDs = TypedDataset.create(apartments)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nWe can also create one from an existing Spark Dataset:\nval aptDs = spark.createDataset(apartments)\n// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nval aptTypedDs = TypedDataset.create(aptDs)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nOr use the Frameless syntax:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval aptTypedDs2 = aptDs.typed\n// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nTypesafe column referencing\nThis is how we select a particular column from a TypedDataset:\nval cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))\n// cities: frameless.TypedDataset[String] = [_1: string]\n\nThis is completely type-safe, for instance suppose we misspell city as citi:\naptTypedDs.select(aptTypedDs('citi))\n// :28: error: No column Symbol with shapeless.tag.Tagged[String(\"citi\")] of type A in Apartment\n//        aptTypedDs.select(aptTypedDs('citi))\n//                                    ^\n\nThis gets raised at compile-time, whereas with the standard Dataset API the error appears at run-time (enjoy the stack trace):\naptDs.select('citi)\n// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [city, surface, price];;\n// 'Project ['citi]\n// +- LocalRelation [city#206, surface#207, price#208]\n// \n//   at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:77)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:74)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:69)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:307)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionUp$1(QueryPlan.scala:269)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:279)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2$1.apply(QueryPlan.scala:283)\n//   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n//   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n//   at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)\n//   at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)\n//   at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n//   at scala.collection.AbstractTraversable.map(Traversable.scala:104)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:283)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$8.apply(QueryPlan.scala:288)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:186)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:288)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:74)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:67)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:126)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:67)\n//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:58)\n//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:49)\n//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:64)\n//   at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2603)\n//   at org.apache.spark.sql.Dataset.select(Dataset.scala:969)\n//   ... 458 elided\n\nselect() supports arbitrary column operations:\naptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()\n// +----+---+\n// |  _1| _2|\n// +----+---+\n// | 500| 52|\n// |1000|102|\n// | 250| 27|\n// | 830| 85|\n// | 450| 47|\n// | 740| 76|\n// +----+---+\n//\n\nNote that unlike the standard Spark API where some operations are lazy and some are not, TypedDatasets have all operations to be lazy. \nIn the above example, show() is lazy. It requires to apply run() for the show job to materialize.\nA more detailed explanation of Job is given here.\nNext we compute the price by surface unit:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// :27: error: overloaded method value / with alternatives:\n//   (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] \n//   (u: frameless.TypedColumn[Apartment,Double])(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double]\n//  cannot be applied to (frameless.TypedColumn[Apartment,Int])\n//        val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n//                                                                      ^\n\nAs the error suggests, we can't divide a TypedColumn of Double by Int. \nFor safety, in Frameless only math operations between same types is allowed. \nThere are two ways to proceed here: \n(a) Explicitly cast Int to Double (manual)\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect().run()\n// res6: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\n(b) Perform the cast implicitly (automated)\nimport frameless.implicits.widen._\n// import frameless.implicits.widen._\n\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect.run()\n// res7: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\nLooks like it worked, but that cast seems unsafe right? Actually it is safe.\nLet's try to cast a TypedColumn of String to Double:\naptTypedDs('city).cast[Double]\n// :31: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]\n//        aptTypedDs('city).cast[Double]\n//                              ^\n\nThe compile-time error tells us that to perform the cast, an evidence \n(in the form of CatalystCast[String, Double]) must be available. \nSince casting from String to Double is not allowed, this results \nin a compilation error. \nCheck here \nfor the set of available CatalystCast.\nTypeSafe TypedDataset casting and projections\nWith select() the resulting TypedDataset is of type TypedDataset[TupleN[...]] (with N in [1...10]).\nFor example, if we select three columns with types String, Int, and Boolean the result will have type\nTypedDataset[(String, Int, Boolean)]. To select more than ten columns use the selectMany() method. \nSelect has better IDE support than the macro based selectMany, so prefer select() for the general case. \nWe often want to give more expressive types to the result of our computations.\nas[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long\nas the types in U and T align.\nWhen the cast is valid the expression compiles:\ncase class UpdatedSurface(city: String, surface: Int)\n// defined class UpdatedSurface\n\nval updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]\n// updated: frameless.TypedDataset[UpdatedSurface] = [city: string, surface: int]\n\nupdated.show(2).run()\n// +-----+-------+\n// | city|surface|\n// +-----+-------+\n// |Paris|     52|\n// |Paris|    102|\n// +-----+-------+\n// only showing top 2 rows\n//\n\nNext we try to cast a (String, String) to an UpdatedSurface (which has types String, Int).\nThe cast is not valid and the expression does not compile:\naptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// :33: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]\n//        aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n//                                                                  ^\n\nProjections\nWe often want to work with a subset of the fields in a dataset.\nProjections allows to easily select the fields we are interested\nwhile preserving their initial name and types for extra safety.\nHere is an example using the TypedDataset[Apartment] with an additional column:\nimport frameless.implicits.widen._\n// import frameless.implicits.widen._\n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\ncase class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)\n// defined class ApartmentDetails\n\nval aptWithRatio = aptds.select(aptds('city), aptds('price), aptds('surface), aptds('price) / aptds('surface)).as[ApartmentDetails]\n// aptWithRatio: frameless.TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]\n\nSuppose we only want to work with city and ratio:\ncase class CityInfo(city: String, ratio: Double)\n// defined class CityInfo\n\nval cityRatio = aptWithRatio.project[CityInfo]\n// cityRatio: frameless.TypedDataset[CityInfo] = [city: string, ratio: double]\n\ncityRatio.show(2).run()\n// +-----+------+\n// | city| ratio|\n// +-----+------+\n// |Paris|6000.0|\n// |Paris|4500.0|\n// +-----+------+\n// only showing top 2 rows\n//\n\nSuppose we only want to work with price and ratio:\ncase class PriceInfo(ratio: Double, price: Double)\n// defined class PriceInfo\n\nval priceInfo = aptWithRatio.project[PriceInfo]\n// priceInfo: frameless.TypedDataset[PriceInfo] = [ratio: double, price: double]\n\npriceInfo.show(2).run()\n// +------+--------+\n// | ratio|   price|\n// +------+--------+\n// |6000.0|300000.0|\n// |4500.0|450000.0|\n// +------+--------+\n// only showing top 2 rows\n//\n\nWe see that the order of the fields does not matter as long as the\nnames and the corresponding types agree. However, if we make a mistake in\nany of the names and/or their types, then we get a compilation error.\nSay we make a typo in a field name:\ncase class PriceInfo2(ratio: Double, pricEE: Double)\n\naptWithRatio.project[PriceInfo2]\n// :36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?\n//        aptWithRatio.project[PriceInfo2]\n//                            ^\n\nSay we make a mistake in the corresponding type:\ncase class PriceInfo3(ratio: Int, price: Double) // ratio should be Double\n\naptWithRatio.project[PriceInfo3]\n// :36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?\n//        aptWithRatio.project[PriceInfo3]\n//                            ^\n\nUser Defined Functions\nFrameless supports lifting any Scala function (up to five arguments) to the\ncontext of a particular TypedDataset:\n// The function we want to use as UDF\nval priceModifier =\n    (name: String, price:Double) => if(name == \"Paris\") price * 2.0 else price\n// priceModifier: (String, Double) => Double = \n\nval udf = aptTypedDs.makeUDF(priceModifier)\n// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = \n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nval adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))\n// adjustedPrice: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\nadjustedPrice.show().run()\n// +-----+--------+\n// |   _1|      _2|\n// +-----+--------+\n// |Paris|600000.0|\n// |Paris|900000.0|\n// |Paris|500000.0|\n// | Lyon|200000.0|\n// | Lyon|133000.0|\n// | Nice|325000.0|\n// +-----+--------+\n//\n\nGroupBy and Aggregations\nLet's suppose we wanted to retrieve the average apartment price in each city\nval priceByCity = aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('price)))\n// priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\npriceByCity.collect().run()\n// res17: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))\n\nAgain if we try to aggregate a column that can't be aggregated, we get a compilation error\naptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                         ^\n// :34: error: could not find implicit value for parameter averageable: frameless.CatalystAverageable[String,Out]\n//        aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                         ^\n//                                                     ^\n// :34: warning: postfix operator ^ should be enabled\n// by making the implicit value scala.language.postfixOps visible.\n// This can be achieved by adding the import clause 'import scala.language.postfixOps'\n// or by setting the compiler option -language:postfixOps.\n// See the Scaladoc for value scala.language.postfixOps for a discussion\n// why the feature should be explicitly enabled.\n//        aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                         ^\n//                                                                                                                                  ^\n\nNext, we combine select and groupBy to calculate the average price/surface ratio per city:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nval cityPriceRatio =  aptds.select(aptds('city), aptds('price) / aptds('surface))\n// cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\ncityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()\n// +-----+------------------+\n// |   _1|                _2|\n// +-----+------------------+\n// | Nice| 4391.891891891892|\n// |Paris| 6833.333333333333|\n// | Lyon|2682.5970548862115|\n// +-----+------------------+\n//\n\nEntire TypedDataset Aggregation\nWe often want to aggregate the entire TypedDataset and skip the groupBy() clause.\nIn Frameless you can do this using the agg() operator directly on the TypedDataset. \nIn the following example, we compute the average price, the average surface,the minimum surface, and the set of cities for the entire dataset. \ncase class Stats(\n   avgPrice: Double, \n   avgSurface: Double, \n   minSurface: Int, \n   allCities: Vector[String])\n// defined class Stats\n\naptds.agg(\n   avg(aptds('price)), \n   avg(aptds('surface)),\n   min(aptds('surface)),\n   collectSet(aptds('city))\n).as[Stats].show().run() \n// +-----------------+------------------+----------+-------------------+\n// |         avgPrice|        avgSurface|minSurface|          allCities|\n// +-----------------+------------------+----------+-------------------+\n// |276333.3333333333|62.833333333333336|        25|[Paris, Nice, Lyon]|\n// +-----------------+------------------+----------+-------------------+\n//\n\nJoins\ncase class CityPopulationInfo(name: String, population: Int)\n\nval cityInfo = Seq(\n  CityPopulationInfo(\"Paris\", 2229621),\n  CityPopulationInfo(\"Lyon\", 500715),\n  CityPopulationInfo(\"Nice\", 343629)\n)\n\nval citiInfoTypedDS = TypedDataset.create(cityInfo)\n\nHere is how to join the population information to the apartment's dataset.\nval withCityInfo = aptTypedDs.join(citiInfoTypedDS, aptTypedDs('city), citiInfoTypedDS('name))\n// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct, _2: struct]\n\nwithCityInfo.show().run()\n// +--------------------+---------------+\n// |                  _1|             _2|\n// +--------------------+---------------+\n// | [Paris,50,300000.0]|[Paris,2229621]|\n// |[Paris,100,450000.0]|[Paris,2229621]|\n// | [Paris,25,250000.0]|[Paris,2229621]|\n// |  [Lyon,83,200000.0]|  [Lyon,500715]|\n// |  [Lyon,45,133000.0]|  [Lyon,500715]|\n// |  [Nice,74,325000.0]|  [Nice,343629]|\n// +--------------------+---------------+\n//\n\nThe joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].\nWe can then select which information we want to continue to work with:\ncase class AptPriceCity(city: String, aptPrice: Double, cityPopulation: Int)\n// defined class AptPriceCity\n\nwithCityInfo.select(\n   withCityInfo.colMany('_2, 'name), withCityInfo.colMany('_1, 'price), withCityInfo.colMany('_2, 'population)\n).as[AptPriceCity].show().run\n// +-----+--------+--------------+\n// | city|aptPrice|cityPopulation|\n// +-----+--------+--------------+\n// |Paris|300000.0|       2229621|\n// |Paris|450000.0|       2229621|\n// |Paris|250000.0|       2229621|\n// | Lyon|200000.0|        500715|\n// | Lyon|133000.0|        500715|\n// | Nice|325000.0|        343629|\n// +-----+--------+--------------+\n//\n\n"},"TypedDatasetVsSparkDataset.html":{"url":"TypedDatasetVsSparkDataset.html","title":"Comparing TypedDatasets with Spark's Datasets","keywords":"","body":"Comparing TypedDatasets with Spark's Datasets\nGoal:\n  This tutorial compares the standard Spark Datasets api with the one provided by\n  frameless' TypedDataset. It shows how TypedDatsets allows for an expressive and\n  type-safe api with no compromises on performance.\nFor this tutorial we first create a simple dataset and save it on disk as a parquet file.\nParquet is a popular columnar format and well supported by Spark.\nIt's important to note that when operating on parquet datasets, Spark knows that each column is stored\nseparately, so if we only need a subset of the columns Spark will optimize for this and avoid reading\nthe entire dataset. This is a rather simplistic view of how Spark and parquet work together but it\nwill serve us well for the context of this discussion.\nimport spark.implicits._\n// import spark.implicits._\n\n// Our example case class Foo acting here as a schema\ncase class Foo(i: Long, j: String)\n// defined class Foo\n\n// Assuming spark is loaded and SparkSession is bind to spark\nval initialDs = spark.createDataset( Foo(1, \"Q\") :: Foo(10, \"W\") :: Foo(100, \"E\") :: Nil )\n// initialDs: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\n// Assuming you are on Linux or Mac OS\ninitialDs.write.parquet(\"/tmp/foo\")\n\nval ds = spark.read.parquet(\"/tmp/foo\").as[Foo]\n// ds: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\nds.show()\n// +---+---+\n// |  i|  j|\n// +---+---+\n// |100|  E|\n// |  1|  Q|\n// | 10|  W|\n// +---+---+\n//\n\nThe value ds holds the content of the initialDs read from a parquet file.\nLet's try to only use field i from Foo and see how Spark's Catalyst (the query optimizer)\noptimizes this.\n// Using a standard Spark TypedColumn in select()\nval filteredDs = ds.filter($\"i\" === 10).select($\"i\".as[Long])\n// filteredDs: org.apache.spark.sql.Dataset[Long] = [i: bigint]\n\nfilteredDs.show()\n// +---+\n// |  i|\n// +---+\n// | 10|\n// +---+\n//\n\nThe filteredDs is of type Dataset[Long]. Since we only access field i from Foo the type is correct.\nUnfortunately, this syntax requires handholding by explicitly setting the TypedColumn in the select statement\nto return type Long (look at the as[Long] statement). We will discuss this limitation next in more detail.\nNow, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.\nfilteredDs.explain()\n// == Physical Plan ==\n// *Project [i#69L]\n// +- *Filter (isnotnull(i#69L) && (i#69L = 10))\n//    +- *BatchedScan parquet [i#69L] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nThe last line is very important (see ReadSchema). The schema read\nfrom the parquet file only required reading column i without needing to access column j.\nThis is great! We have both an optimized query plan and type-safety!\nUnfortunately, this syntax is not bulletproof: it fails at run-time if we try to access\na non existing column x:\nscala> ds.filter($\"i\" === 10).select($\"x\".as[Long])\norg.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];;\n'Project ['x]\n+- Filter (i#69L = cast(10 as bigint))\n   +- Relation[i#69L,j#70] parquet\n\n  at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:77)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:74)\n  at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n  at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n  at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:69)\n  at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:307)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionUp$1(QueryPlan.scala:269)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:279)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2$1.apply(QueryPlan.scala:283)\n  at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n  at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n  at scala.collection.immutable.List.foreach(List.scala:392)\n  at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n  at scala.collection.immutable.List.map(List.scala:296)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:283)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$8.apply(QueryPlan.scala:288)\n  at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:186)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:288)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:74)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:67)\n  at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:126)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:67)\n  at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:58)\n  at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:49)\n  at org.apache.spark.sql.Dataset.(Dataset.scala:161)\n  at org.apache.spark.sql.Dataset.(Dataset.scala:167)\n  at org.apache.spark.sql.Dataset.select(Dataset.scala:1023)\n  ... 450 elided\n\nThere are two things to improve here. First, we would want to avoid the at[Long] casting that we are required\nto type for type-safety. This is clearly an area where we can introduce a bug by casting to an incompatible\ntype. Second, we want a solution where reference to a\nnon existing column name fails at compilation time.\nThe standard Spark Dataset can achieve this using the following syntax.\nds.filter(_.i == 10).map(_.i).show()\n// +-----+\n// |value|\n// +-----+\n// |   10|\n// +-----+\n//\n\nThis looks great! It reminds us the familiar syntax from Scala.\nThe two closures in filter and map are functions that operate on Foo and the\ncompiler will helps us capture all the mistakes we mentioned above.\nscala> ds.filter(_.i == 10).map(_.x).show()\n:20: error: value x is not a member of Foo\n       ds.filter(_.i == 10).map(_.x).show()\n                                  ^\n\nUnfortunately, this syntax does not allow Spark to optimize the code.\nds.filter(_.i == 10).map(_.i).explain()\n// == Physical Plan ==\n// *SerializeFromObject [input[0, bigint, true] AS value#105L]\n// +- *MapElements , obj#104: bigint\n//    +- *DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#103: $line14.$read$$iw$$iw$$iw$$iw$Foo\n//       +- *Filter .apply\n//          +- *BatchedScan parquet [i#69L,j#70] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [], ReadSchema: struct\n\nAs we see from the explained Physical Plan, Spark was not able to optimize our query as before.\nReading the parquet file will required loading all the fields of Foo. This might be ok for\nsmall datasets or for datasets with few columns, but will be extremely slow for most practical\napplications.\nIntuitively, Spark currently doesn't have a way to look inside the code we pass in these two\nclosures. It only knows that they both take one argument of type Foo, but it has no way of knowing if\nwe use just one or all of Foo's fields.\nThe TypedDataset in frameless solves this problem. It allows for a simple and type-safe syntax\nwith a fully optimized query plan.\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nval fds = TypedDataset.create(ds)\n// fds: frameless.TypedDataset[Foo] = [i: bigint, j: string]\n\nfds.filter( fds('i) === 10 ).select( fds('i) ).show().run()\n// +---+\n// | _1|\n// +---+\n// | 10|\n// +---+\n//\n\nAnd the optimized Physical Plan:\nfds.filter( fds('i) === 10 ).select( fds('i) ).explain()\n// == Physical Plan ==\n// *Project [i#69L AS _1#176L]\n// +- *Filter (isnotnull(i#69L) && (i#69L = 10))\n//    +- *BatchedScan parquet [i#69L] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nAnd the compiler is our friend.\nscala> fds.filter( fds('i) === 10 ).select( fds('x) )\n:21: error: No column Symbol with shapeless.tag.Tagged[String(\"x\")] of type A in Foo\n       fds.filter( fds('i) === 10 ).select( fds('x) )\n                                               ^\n\nDifferences in Encoders\nEncoders in Spark's Datasets are partially type-safe. If you try to create a Dataset using  a type that is not \n a Scala Product then you get a compilation error:\nclass Bar(i: Int)\n// defined class Bar\n\nBar is neither a case class nor a Product, so the following correctly gives a compilation error in Spark:\nscala> spark.createDataset(Seq(new Bar(1)))\n:21: error: Unable to find encoder for type stored in a Dataset.  Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._  Support for serializing other types will be added in future releases.\n       spark.createDataset(Seq(new Bar(1)))\n                          ^\n\nHowever, the compile type guards implemented in Spark are not sufficient to detect non encodable members. \nFor example, using the following case class leads to a runtime failure:\ncase class MyDate(jday: java.util.Date)\n// defined class MyDate\n\nval myDateDs = spark.createDataset(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// java.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n// - field (class: \"java.util.Date\", name: \"jday\")\n// - root class: \"MyDate\"\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:598)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:592)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:583)\n//   at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n//   at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n//   at scala.collection.immutable.List.foreach(List.scala:392)\n//   at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n//   at scala.collection.immutable.List.flatMap(List.scala:355)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:583)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:425)\n//   at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:61)\n//   at org.apache.spark.sql.Encoders$.product(Encoders.scala:274)\n//   at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:47)\n//   ... 770 elided\n\nIn comparison, a TypedDataset will notify about the encoding problem at compile time: \nTypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// :22: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[MyDate]\n//        TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n//                           ^\n\n"},"TypedEncoder.html":{"url":"TypedEncoder.html","title":"Typed Encoders in Frameless","keywords":"","body":"Typed Encoders in Frameless\nSpark uses Reflection to derive it's Encoders, which is why they can fail at run time. For example, because Spark does not supports java.util.Date, the following leads to an error:\nimport org.apache.spark.sql.Dataset\nimport spark.implicits._\n\ncase class DateRange(s: java.util.Date, e: java.util.Date)\n\nscala> val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))\njava.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n- field (class: \"java.util.Date\", name: \"s\")\n- root class: \"DateRange\"\n  at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:598)\n  at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:592)\n  at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:583)\n  at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n  at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n  at scala.collection.immutable.List.foreach(List.scala:392)\n  at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n  at scala.collection.immutable.List.flatMap(List.scala:355)\n  at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:583)\n  at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:425)\n  at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:61)\n  at org.apache.spark.sql.Encoders$.product(Encoders.scala:274)\n  at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:47)\n  ... 230 elided\n\nAs shown by the stack trace, this runtime error goes thought ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection based approach is it's inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.\nFrameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the code java.util.Date example won't compile with frameless:\nimport frameless.TypedDataset\n\nval ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// :26: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]\n//        val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n//                                                             ^\n\nType class derivation takes case or recursively constructing (and proving the existence) TypeEncoders for case classes. The following works as expected:\ncase class Bar(d: Double, s: String)\n// defined class Bar\n\ncase class Foo(i: Int, b: Bar)\n// defined class Foo\n\nval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, \"s\"))))\n// ds: frameless.TypedDataset[Foo] = [i: int, b: struct]\n\nds.collect()\n// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@8a0bd3c\n\nBut any non-encodable in the case class hierarchy will be detected at compile time:\ncase class BarDate(d: Double, s: String, t: java.util.Date)\ncase class FooDate(i: Int, b: BarDate)\n\nval ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// :28: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]\n//        val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n//                                                           ^\n\nIt should be noted that once derived, reflection based Encoders and implicitly derived TypeEncoders have identical performances. The derivation mechanism is different, but the objects generated to encode and decode JVM object in the Spark internal representation behave the same at run-time.\n"},"Injection.html":{"url":"Injection.html","title":"Injection: Creating Custom Encoders","keywords":"","body":"Injection: Creating Custom Encoders\nInjection lets us define encoders for types that do not have one by injecting A into an encodable type B.\nThis is the definition of the injection typeclass:\ntrait Injection[A, B] extends Serializable {\n  def apply(a: A): B\n  def invert(b: B): A\n}\n\nExample\nLet's define a simple case class:\ncase class Person(age: Int, birthday: java.util.Date)\n// defined class Person\n\nval people = Seq(Person(42, new java.util.Date))\n// people: Seq[Person] = List(Person(42,Tue May 23 10:57:10 CEST 2017))\n\nAnd an instance of a TypedDataset:\nval personDS = TypedDataset.create(people)\n// :24: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n//        val personDS = TypedDataset.create(people)\n//                                          ^\n\nLooks like we can't, a TypedEncoder instance of Person is not available, or more precisely for java.util.Date.\nBut we can define a injection from java.util.Date to an encodable type, like Long:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = new Injection[java.util.Date, Long] {\n  def apply(d: java.util.Date): Long = d.getTime()\n  def invert(l: Long): java.util.Date = new java.util.Date(l)\n}\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@6d6cc4bc\n\nWe can be less verbose using the Injection.apply function:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@79ea3da5\n\nNow we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, birthday: bigint]\n\nAnother example\nLet's define a sealed family:\nsealed trait Gender\n// defined trait Gender\n\ncase object Male extends Gender\n// defined object Male\n\ncase object Female extends Gender\n// defined object Female\n\ncase object Other extends Gender\n// defined object Other\n\nAnd a simple case class:\ncase class Person(age: Int, gender: Gender)\n// defined class Person\n\nval people = Seq(Person(42, Male))\n// people: Seq[Person] = List(Person(42,Male))\n\nAgain if we try to create a TypedDataset, we get a compilation error.\nval personDS = TypedDataset.create(people)\n// :32: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n//        val personDS = TypedDataset.create(people)\n//                                          ^\n\nLet's define an injection instance for Gender:\nimplicit val genderToInt: Injection[Gender, Int] = Injection(\n  {\n    case Male   => 1\n    case Female => 2\n    case Other  => 3\n  },\n  {\n    case 1 => Male\n    case 2 => Female\n    case 3 => Other\n  })\n// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@70fdc07e\n\nAnd now we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, gender: int]\n\n"},"Job.html":{"url":"Job.html","title":"Job[A]","keywords":"","body":"Job[A]\nAll operations on TypedDataset are lazy. An operation either returns a new\ntransformed TypedDataset or a Job[A], where A is the result of running a\nnon-lazy computation in Spark. Job serves several functions:\n\nMakes all operations on a TypedDataset lazy, which makes them more predictable compared to having\nfew operations being lazy and other being strict\nAllows the programmer to make expensive blocking operations explicit\nAllows for Spark jobs to be lazily sequenced using monadic composition via for-comprehension\nProvides an obvious place where you can annotate/name your Spark jobs to make it easier\nto track different parts of your application in the Spark UI\n\nThe toy example showcases the use of for-comprehension to explicitly sequences Spark Jobs.\nFirst we calculate the size of the TypedDataset and then we collect to the driver\nexactly 20% of its elements:\nval ds = TypedDataset.create(1 to 20)\n// ds: frameless.TypedDataset[Int] = [_1: int]\n\nval countAndTakeJob =\n  for {\n    count \nThe countAndTakeJob can either be executed using run() (as we show above) or it can\nbe passed along to other parts of the program to be further composed into more complex sequences\nof Spark jobs.\nimport frameless.Job\n// import frameless.Job\n\ndef computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min)\n// computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]\n\nval finalJob = computeMinOfSample(countAndTakeJob)\n// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@2e359e76\n\nNow we can execute this new job by specifying a group-id and a description.\nThis allows the programmer to see this information on the Spark UI and help track, say,\nperformance issues.\nfinalJob.\n  withGroupId(\"samplingJob\").\n  withDescription(\"Samples 20% of elements and computes the min\").\n  run()\n// res2: Int = 1\n\n"},"Cats.html":{"url":"Cats.html","title":"Using Cats with RDDs","keywords":"","body":"Using Cats with RDDs\nData aggregation is one of the most important operations when working with Spark (and data in general).\nFor example, we often have to compute the min, max, avg, etc. from a set of columns grouped by\ndifferent predicates. This section shows how cats simplifies these tasks in Spark by\nleveraging a large collection of Type Classes for ordering and aggregating data.\nAll the examples below assume you have previously imported cats.implicits.\nimport cats.implicits._\n// import cats.implicits._\n\nCats offers ways to sort and aggregate tuples of arbitrary arity.\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nval data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[0] at makeRDD at :21\n\nprintln(data.csum)\n// (10,9,9)\n\nprintln(data.cmax)\n// (8,2,3)\n\nprintln(data.cmin)\n// (1,2,3)\n\nThe following example aggregates all the elements with a common key.\ntype User = String\n// defined type alias User\n\ntype TransactionCount = Int\n// defined type alias TransactionCount\n\nval allData: RDD[(User,TransactionCount)] =\n   sc.makeRDD((\"Bob\", 12) :: (\"Joe\", 1) :: (\"Anna\", 100) :: (\"Bob\", 20) :: (\"Joe\", 2) :: Nil)\n// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[1] at makeRDD at :24\n\nval totalPerUser =  allData.csumByKey\n// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[2] at reduceByKey at implicits.scala:18\n\ntotalPerUser.collectAsMap\n// res7: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)\n\nThe same example would work for more complex keys.\nval allDataComplexKeu =\n   sc.makeRDD( (\"Bob\", Map(\"task1\" -> 10)) ::\n    (\"Joe\", Map(\"task1\" -> 1, \"task2\" -> 3)) :: (\"Bob\", Map(\"task1\" -> 10, \"task2\" -> 1)) :: (\"Joe\", Map(\"task3\" -> 4)) :: Nil )\n// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ParallelCollectionRDD[3] at makeRDD at :22\n\nval overalTasksPerUser = allDataComplexKeu.csumByKey\n// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ShuffledRDD[4] at reduceByKey at implicits.scala:18\n\noveralTasksPerUser.collectAsMap\n// res8: scala.collection.Map[String,scala.collection.immutable.Map[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))\n\nJoins\n// Type aliases for meaningful types\ntype TimeSeries = Map[Int,Int]\n// defined type alias TimeSeries\n\ntype UserName = String\n// defined type alias UserName\n\nExample: Using the implicit full-our-join operator\nimport frameless.cats.outer._\n// import frameless.cats.outer._\n\nval day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 2, 1 -> 4)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Sam\", Map(0 -> 1)) :: Nil )\n// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[5] at makeRDD at :26\n\nval day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 10, 1 -> 11)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Joe\", Map(0 -> 1, 1 -> 2)) :: Nil )\n// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[6] at makeRDD at :26\n\nval daysCombined = day1 |+| day2\n// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[10] at mapValues at implicits.scala:43\n\ndaysCombined.collect()\n// res10: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))\n\nNote how the user's timeseries from different days have been aggregated together.\nThe |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join\non the key and combine values using the default Semigroup for the value type.\nIn cats:\nMap(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)\n// res11: Map[Int,Int] = Map(1 -> 6, 2 -> 2)\n\n"},"TypedDataFrame.html":{"url":"TypedDataFrame.html","title":"Proof of Concept: TypedDataFrame","keywords":"","body":"Proof of Concept: TypedDataFrame\nTypedDataFrame is the API developed in the early stages of frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future developments of frameless. However, the design is interesting enough for being documented.\nTo safely manipulate DataFrames we use a technique called shadow type, which consists in storing additional information about a value in a \"dummy\" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.\nDiving in\nIn TypedDataFrame, we use a single Schema  to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:\nimport org.apache.spark.sql.DataFrame\nimport shapeless.HList\n\nclass TDataFrame[Schema  Boolean): TDataFrame[Schema] = ???\n\n  def select[C \nAs you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.\nType-level column referencing\nFor Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching column referencing at compile type. When everything goes well, frameless select is very similar to vanilla select, except that it keeps track of the selected column types:\nimport frameless.TypedDataFrame\n\ncase class Foo(s: String, d: Double, i: Int)\n\ndef selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n  tf.select('i, 's)\n\nHowever, in case of typo, it gets coughs right away:\ndef selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n  tf.select('j, 's)\n\nType-level joins\nJoins can available with two different syntaxes, the first lets you reference different columns on each TypedDataFrame, and ensures that their all exists and have compatible types:\ncase class Bar(i: Int, j: String, b: Boolean)\n\ndef join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n    : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =\n  tf1.innerJoin(tf2).on('s).and('j)\n\nThe second syntax bring some convenience when the joining columns have identical names in both tables:\ndef join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n    : TypedDataFrame[(String, Double, Int, String, Boolean)] =\n  tf1.innerJoin(tf2).using('i)\n\nFurther example are available in the TypedDataFrame join tests.\nComplete example\nWe now consider a complete example to see how the type system can frameless can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city map and neighborhood:\ntype Neighborhood = String\ntype Address = String\n\ncase class PhoneBookEntry(\n  address: Address,\n  residents: String,\n  phoneNumber: Double\n)\n\ncase class CityMapEntry(\n  address: Address,\n  neighborhood: Neighborhood\n)\n\nOur goal will be to compute the neighborhood with unique names, approximating \"unique\" with names containing less common\nletters in the alphabet: 'x', 'q', and 'z'. We are going to need a natural language processing library at some point, so\nlet's use the following for the example:\nobject NLPLib {\n  def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))\n}\n\nSuppose we manage to obtain a TypedDataFrame[PhoneBookEntry] and a TypedDataFrame[CityMapEntry] public data, here is what our Spark job could look like with frameless:\nimport org.apache.spark.sql.SQLContext\n\n// These case classes are used to hold intermediate results\ncase class Family(residents: String, neighborhood: Neighborhood)\ncase class Person(name: String, neighborhood: Neighborhood)\ncase class NeighborhoodCount(neighborhood: Neighborhood, count: Long)\n\ndef bestNeighborhood\n  (phoneBookTF: TypedDataFrame[PhoneBookEntry], cityMapTF: TypedDataFrame[CityMapEntry])\n  (implicit c: SQLContext): String = {\n                                          (((((((((\n  phoneBookTF\n    .innerJoin(cityMapTF).using('address) :TypedDataFrame[(Address, String, Double, String)])\n    .select('_2, '_4)                     :TypedDataFrame[(String, String)])\n    .as[Family]()                         :TypedDataFrame[Family])\n    .flatMap { f =>\n      f.residents.split(' ').map(r => Person(r, f.neighborhood))\n    }                                     :TypedDataFrame[Person])\n    .filter { p =>\n      NLPLib.uniqueName(p.name)\n    }                                     :TypedDataFrame[Person])\n    .groupBy('neighborhood).count()       :TypedDataFrame[(String, Long)])\n    .as[NeighborhoodCount]()              :TypedDataFrame[NeighborhoodCount])\n    .sortDesc('count)                     :TypedDataFrame[NeighborhoodCount])\n    .select('neighborhood)                :TypedDataFrame[Tuple1[String]])\n    .head._1\n}\n\nIf you compare this version from Spark vanilla where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.\nLimitations\nThe main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.\nIn the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.\n"}}}
\ No newline at end of file

From 691deaabce392a7ca5a80979d608d6253514343a Mon Sep 17 00:00:00 2001
From: imarios 
Date: Wed, 18 Oct 2017 09:43:56 -0700
Subject: [PATCH 003/220] Documentation for 0.4 release.

---
 Cats.html                       | 130 ++++++++++--
 FeatureOverview.html            | 163 ++++++++------
 Injection.html                  |  25 ++-
 Job.html                        |  41 +++-
 TypedDataFrame.html             |  21 +-
 TypedDatasetVsSparkDataset.html | 122 ++++++-----
 TypedEncoder.html               |  45 ++--
 TypedML.html                    | 366 ++++++++++++++++++++++++++++++++
 docs/src/main/tut/README.md     |   3 +-
 index.html                      |  19 +-
 search_index.json               |   2 +-
 11 files changed, 769 insertions(+), 168 deletions(-)
 create mode 100644 TypedML.html

diff --git a/Cats.html b/Cats.html
index 55d1b5f14..1eb001cbb 100644
--- a/Cats.html
+++ b/Cats.html
@@ -57,7 +57,7 @@
     
 
     
-    
+    
     
     
     
@@ -180,7 +180,20 @@

                • -
              • +
              • + + + + + Using Spark ML with TypedDataset + + + + + +
                • + +
              • @@ -238,21 +251,96 @@

                -

                Using Cats with RDDs

                +

                Using Cats with Frameless

                +

                There are two main parts to the cats integration offered by frameless:

                +
                  +
                • effect suspension in TypedDataset using cats-effect and cats-mtl
                  • +
                • RDD enhancements using algebraic typeclasses in cats-kernel
                  • +
                +

                All the examples below assume you have previously imported cats.implicits and frameless.cats.implicits.

                +

                Note that you should not import frameless.syntax._ together with frameless.cats.implicits._.

                +
                import cats.implicits._
+// import cats.implicits._
+
+import frameless.cats.implicits._
+// import frameless.cats.implicits._
+
                +

                Effect Suspension in typed datasets

                +

                As noted in the section about Job, all operations on TypedDataset are lazy. The results of +operations that would normally block on plain Spark APIs are wrapped in a type constructor F[_], +for which there exists an instance of SparkDelay[F]. This typeclass represents the operation of +delaying a computation and capturing an implicit SparkSession.

                +

                In the cats module, we utilize the typeclasses from cats-effect for abstracting over these +effect types - namely, we provide an implicit SparkDelay instance for all F[_] for which exists +an instance of cats.effect.Sync[F].

                +

                This allows one to run operations on TypedDataset in an existing monad stack. For example, given +this pre-existing monad stack:

                +
                import frameless.TypedDataset
+// import frameless.TypedDataset
+
+import cats.data.ReaderT
+// import cats.data.ReaderT
+
+import cats.effect.IO
+// import cats.effect.IO
+
+import cats.effect.implicits._
+// import cats.effect.implicits._
+
+type Action[T] = ReaderT[IO, SparkSession, T]
+// defined type alias Action
+
                +

                We will be able to request that values from TypedDataset will be suspended in this stack:

                +
                val typedDs = TypedDataset.create(Seq((1, "string"), (2, "another")))
+// typedDs: frameless.TypedDataset[(Int, String)] = [_1: int, _2: string]
+
+val result: Action[(Seq[(Int, String)], Long)] = for {
+  sample <- typedDs.take(1)
+  count <- typedDs.count()
+} yield (sample, count)
+// result: Action[(Seq[(Int, String)], Long)] = Kleisli(<function1>)
+
                +

                As with Job, note that nothing has been run yet. The effect has been properly suspended. To +run our program, we must first supply the SparkSession to the ReaderT layer and then +run the IO effect:

                +
                result.run(spark).unsafeRunSync()
+// res5: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)
+
                +

                Convenience methods for modifying Spark thread-local variables

                +

                The frameless.cats.implicits._ import also provides some syntax enrichments for any monad +stack that has the same capabilities as Action above. Namely, the ability to provide an +instance of SparkSession and the ability to suspend effects.

                +

                For these to work, we will need to import the implicit machinery from the cats-mtl library:

                +
                import cats.mtl.implicits._
+// import cats.mtl.implicits._
+
                +

                And now, we can set the description for the computation being run:

                +
                val resultWithDescription: Action[(Seq[(Int, String)], Long)] = for {
+  r <- result.withDescription("fancy cats")
+  session <- ReaderT.ask[IO, SparkSession]
+  _ <- ReaderT.lift {
+         IO {
+           println(s"Description: ${session.sparkContext.getLocalProperty("spark.job.description")}")
+         }
+       }
+} yield r
+// resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli(<function1>)
+
+resultWithDescription.run(spark).unsafeRunSync()
+// Description: fancy cats
+// res6: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)
+
                +

                Using algebraic typeclasses from Cats with RDDs

                Data aggregation is one of the most important operations when working with Spark (and data in general). For example, we often have to compute the min, max, avg, etc. from a set of columns grouped by different predicates. This section shows how cats simplifies these tasks in Spark by leveraging a large collection of Type Classes for ordering and aggregating data.

                -

                All the examples below assume you have previously imported cats.implicits.

                -
                import cats.implicits._
-// import cats.implicits._
-

                Cats offers ways to sort and aggregate tuples of arbitrary arity.

                import frameless.cats.implicits._
 // import frameless.cats.implicits._
 
 val data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)
-// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[0] at makeRDD at <console>:21
+// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[14] at makeRDD at <console>:45
 
 println(data.csum)
 // (10,9,9)
@@ -272,25 +360,25 @@ 
                Using Cats with RDDs
                
 
 val allData: RDD[(User,TransactionCount)] =
    sc.makeRDD(("Bob", 12) :: ("Joe", 1) :: ("Anna", 100) :: ("Bob", 20) :: ("Joe", 2) :: Nil)
-// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[1] at makeRDD at <console>:24
+// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[15] at makeRDD at <console>:48
 
 val totalPerUser =  allData.csumByKey
-// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[2] at reduceByKey at implicits.scala:18
+// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[16] at reduceByKey at implicits.scala:18
 
 totalPerUser.collectAsMap
-// res7: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)
+// res10: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)

                The same example would work for more complex keys.

                val allDataComplexKeu =
    sc.makeRDD( ("Bob", Map("task1" -> 10)) ::
     ("Joe", Map("task1" -> 1, "task2" -> 3)) :: ("Bob", Map("task1" -> 10, "task2" -> 1)) :: ("Joe", Map("task3" -> 4)) :: Nil )
-// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ParallelCollectionRDD[3] at makeRDD at <console>:22
+// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ParallelCollectionRDD[17] at makeRDD at <console>:46
 
 val overalTasksPerUser = allDataComplexKeu.csumByKey
-// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ShuffledRDD[4] at reduceByKey at implicits.scala:18
+// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ShuffledRDD[18] at reduceByKey at implicits.scala:18
 
 overalTasksPerUser.collectAsMap
-// res8: scala.collection.Map[String,scala.collection.immutable.Map[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))
+// res11: scala.collection.Map[String,scala.collection.immutable.Map[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))

                Joins

                // Type aliases for meaningful types
@@ -305,23 +393,23 @@ 
                Joins
                
 // import frameless.cats.outer._
 
 val day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 2, 1 -> 4)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Sam", Map(0 -> 1)) :: Nil )
-// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[5] at makeRDD at <console>:26
+// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[19] at makeRDD at <console>:50
 
 val day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 10, 1 -> 11)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Joe", Map(0 -> 1, 1 -> 2)) :: Nil )
-// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[6] at makeRDD at <console>:26
+// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[20] at makeRDD at <console>:50
 
 val daysCombined = day1 |+| day2
-// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[10] at mapValues at implicits.scala:43
+// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[24] at mapValues at implicits.scala:43
 
 daysCombined.collect()
-// res10: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))
+// res13: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))

                Note how the user's timeseries from different days have been aggregated together. The |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join on the key and combine values using the default Semigroup for the value type.

                In cats:

                Map(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)
-// res11: Map[Int,Int] = Map(1 -> 6, 2 -> 2)
+// res14: Map[Int,Int] = Map(1 -> 6, 2 -> 2)
                @@ -355,7 +443,7 @@

                No results matching " - + @@ -366,7 +454,7 @@

                No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"next":{"title":"Proof of Concept: TypedDataFrame","level":"1.8","depth":1,"path":"TypedDataFrame.md","ref":"TypedDataFrame.md","articles":[]},"previous":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Cats.md","mtime":"2017-05-23T08:57:27.070Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-23T08:59:39.758Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"next":{"title":"Using Spark ML with TypedDataset","level":"1.8","depth":1,"path":"TypedML.md","ref":"TypedML.md","articles":[]},"previous":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Cats.md","mtime":"2017-10-18T16:21:18.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-10-18T16:22:33.699Z"},"basePath":".","book":{"language":""}}); }); diff --git a/FeatureOverview.html b/FeatureOverview.html index 1399710c2..872ffe30e 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -180,7 +180,20 @@

                • -
              • +
              • + + + + + Using Spark ML with TypedDataset + + + + + +
                • + +
              • @@ -255,35 +268,35 @@

                TypedDataset: Feature Overview

                Creating TypedDataset instances

                We start by defining a case class:

                -
                case class Apartment(city: String, surface: Int, price: Double)
+
                case class Apartment(city: String, surface: Int, price: Double, bedrooms: Int)
 
                
 
                And few Apartment instances:
                
 
                val apartments = Seq(
-  Apartment("Paris", 50, 300000.0),
-  Apartment("Paris", 100, 450000.0),
-  Apartment("Paris", 25, 250000.0),
-  Apartment("Lyon", 83, 200000.0),
-  Apartment("Lyon", 45, 133000.0),
-  Apartment("Nice", 74, 325000.0)
+  Apartment("Paris", 50,  300000.0, 2),
+  Apartment("Paris", 100, 450000.0, 3),
+  Apartment("Paris", 25,  250000.0, 1),
+  Apartment("Lyon",  83,  200000.0, 2),
+  Apartment("Lyon",  45,  133000.0, 1),
+  Apartment("Nice",  74,  325000.0, 3)
 )
 
                
 
                We are now ready to instantiate a TypedDataset[Apartment]:
                
 
                val aptTypedDs = TypedDataset.create(apartments)
-// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]
+// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
 
                
 
                We can also create one from an existing Spark Dataset:
                
 
                val aptDs = spark.createDataset(apartments)
-// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 1 more field]
+// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 2 more fields]
 
 val aptTypedDs = TypedDataset.create(aptDs)
-// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]
+// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
 
                
 
                Or use the Frameless syntax:
                
 
                import frameless.syntax._
 // import frameless.syntax._
 
 val aptTypedDs2 = aptDs.typed
-// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]
+// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
 
                
 
                Typesafe column referencing
                
 
                This is how we select a particular column from a TypedDataset:
                
@@ -298,40 +311,43 @@ 
                Typesafe column referencing

                This gets raised at compile-time, whereas with the standard Dataset API the error appears at run-time (enjoy the stack trace):

                aptDs.select('citi)
-// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [city, surface, price];;
+// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [city, surface, price, bedrooms];;
 // 'Project ['citi]
-// +- LocalRelation [city#206, surface#207, price#208]
+// +- LocalRelation [city#53, surface#54, price#55, bedrooms#56]
 // 
 //   at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:77)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:74)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)
-//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:69)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:307)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionUp$1(QueryPlan.scala:269)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:279)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2$1.apply(QueryPlan.scala:283)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:88)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:85)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)
+//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:70)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:288)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:279)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:289)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1$1.apply(QueryPlan.scala:293)
 //   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)
 //   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)
 //   at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)
 //   at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)
 //   at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)
 //   at scala.collection.AbstractTraversable.map(Traversable.scala:104)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:283)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$8.apply(QueryPlan.scala:288)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:186)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:288)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:74)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:67)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:126)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:67)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:58)
-//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:49)
-//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:64)
-//   at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2603)
-//   at org.apache.spark.sql.Dataset.select(Dataset.scala:969)
-//   ... 458 elided
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:293)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$6.apply(QueryPlan.scala:298)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:187)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:298)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:268)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:85)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)
+//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)
+//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:66)
+//   at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2872)
+//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1153)
+//   ... 434 elided

                select() supports arbitrary column operations:

                aptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()
@@ -354,7 +370,7 @@ 
                Typesafe column referencing
                
 
                val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))
 // <console>:27: error: overloaded method value / with alternatives:
 //   (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] <and>
-//   (u: frameless.TypedColumn[Apartment,Double])(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double]
+//   [Out](other: frameless.TypedColumn[Apartment,Double])(implicit n: frameless.CatalystDivisible[Double,Out], implicit e: frameless.TypedEncoder[Out])frameless.TypedColumn[Apartment,Out]
 //  cannot be applied to (frameless.TypedColumn[Apartment,Int])
 //        val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))
 //                                                                      ^
@@ -433,7 +449,7 @@ 
                Projections
                
 // import frameless.implicits.widen._
 
 val aptds = aptTypedDs // For shorter expressions
-// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]
+// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
 
 case class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)
 // defined class ApartmentDetails
@@ -506,7 +522,7 @@ 
                User Defined Functions
                
 // udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = <function2>
 
 val aptds = aptTypedDs // For shorter expressions
-// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]
+// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
 
 val adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))
 // adjustedPrice: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]
@@ -533,22 +549,14 @@ 
                GroupBy and Aggregations
                
 // res17: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))
 
                
 
                Again if we try to aggregate a column that can't be aggregated, we get a compilation error
                
-
                aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                         ^
-// <console>:34: error: could not find implicit value for parameter averageable: frameless.CatalystAverageable[String,Out]
-//        aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                         ^
+
                aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                        
+// <console>:34: error: Cannot compute average of type String.
+//        aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))
 //                                                     ^
-// <console>:34: warning: postfix operator ^ should be enabled
-// by making the implicit value scala.language.postfixOps visible.
-// This can be achieved by adding the import clause 'import scala.language.postfixOps'
-// or by setting the compiler option -language:postfixOps.
-// See the Scaladoc for value scala.language.postfixOps for a discussion
-// why the feature should be explicitly enabled.
-//        aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                         ^
-//                                                                                                                                  ^
 
                
 
                Next, we combine select and groupBy to calculate the average price/surface ratio per city:
                
 
                val aptds = aptTypedDs // For shorter expressions
-// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]
+// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
 
 val cityPriceRatio =  aptds.select(aptds('city), aptds('price) / aptds('surface))
 // cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]
@@ -563,6 +571,41 @@ 
                GroupBy and Aggregations
                
 // +-----+------------------+
 //
 
                
+
                We can also use pivot to further group data on a secondary column. 
+For example, we can compare the average price across cities by number of bedrooms.  
                
+
                case class BedroomStats(
+   city: String, 
+   AvgPriceBeds1: Option[Double], // Pivot values may be missing, so we encode them using Options
+   AvgPriceBeds2: Option[Double], 
+   AvgPriceBeds3: Option[Double], 
+   AvgPriceBeds4: Option[Double])
+// defined class BedroomStats
+
+val bedroomStats = aptds.
+   groupBy(aptds('city)).
+   pivot(aptds('bedrooms)).
+   on(1,2,3,4). // We only care for up to 4 bedrooms
+   agg(avg(aptds('price))).
+   as[BedroomStats]  // Typesafe casting
+// bedroomStats: frameless.TypedDataset[BedroomStats] = [city: string, AvgPriceBeds1: double ... 3 more fields]
+
+bedroomStats.show().run()
+// +-----+-------------+-------------+-------------+-------------+
+// | city|AvgPriceBeds1|AvgPriceBeds2|AvgPriceBeds3|AvgPriceBeds4|
+// +-----+-------------+-------------+-------------+-------------+
+// | Nice|         null|         null|     325000.0|         null|
+// |Paris|     250000.0|     300000.0|     450000.0|         null|
+// | Lyon|     133000.0|     200000.0|         null|         null|
+// +-----+-------------+-------------+-------------+-------------+
+//
+
                
+
                With pivot, collecting data preserves typesafety by 
+encoding potentially missing columns with Option.
                
+
                bedroomStats.collect().run().foreach(println)
+// BedroomStats(Nice,None,None,Some(325000.0),None)
+// BedroomStats(Paris,Some(250000.0),Some(300000.0),Some(450000.0),None)
+// BedroomStats(Lyon,Some(133000.0),Some(200000.0),None,None)
+
                
 
                Entire TypedDataset Aggregation
                
 
                We often want to aggregate the entire TypedDataset and skip the groupBy() clause.
 In Frameless you can do this using the agg() operator directly on the TypedDataset. 
@@ -600,18 +643,18 @@ 
                Joins
                
 
                
 
                Here is how to join the population information to the apartment's dataset.
                
 
                val withCityInfo = aptTypedDs.join(citiInfoTypedDS, aptTypedDs('city), citiInfoTypedDS('name))
-// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct<city: string, surface: int ... 1 more field>, _2: struct<name: string, population: int>]
+// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct<city: string, surface: int ... 2 more fields>, _2: struct<name: string, population: int>]
 
 withCityInfo.show().run()
 // +--------------------+---------------+
 // |                  _1|             _2|
 // +--------------------+---------------+
-// | [Paris,50,300000.0]|[Paris,2229621]|
-// |[Paris,100,450000.0]|[Paris,2229621]|
-// | [Paris,25,250000.0]|[Paris,2229621]|
-// |  [Lyon,83,200000.0]|  [Lyon,500715]|
-// |  [Lyon,45,133000.0]|  [Lyon,500715]|
-// |  [Nice,74,325000.0]|  [Nice,343629]|
+// |[Paris,50,300000....|[Paris,2229621]|
+// |[Paris,100,450000...|[Paris,2229621]|
+// |[Paris,25,250000....|[Paris,2229621]|
+// |[Lyon,83,200000.0,2]|  [Lyon,500715]|
+// |[Lyon,45,133000.0,1]|  [Lyon,500715]|
+// |[Nice,74,325000.0,3]|  [Nice,343629]|
 // +--------------------+---------------+
 //
 
                
@@ -678,7 +721,7 @@ 
                No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"next":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"previous":{"title":"Introduction","level":"1.1","depth":1,"path":"README.md","ref":"README.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"FeatureOverview.md","mtime":"2017-05-23T08:58:06.851Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-23T08:59:39.758Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"next":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"previous":{"title":"Introduction","level":"1.1","depth":1,"path":"README.md","ref":"README.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"FeatureOverview.md","mtime":"2017-10-18T16:21:37.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-10-18T16:22:33.699Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/Injection.html b/Injection.html
index 6ac336957..b9ab9dfaf 100644
--- a/Injection.html
+++ b/Injection.html
@@ -180,7 +180,20 @@
                • -
              • +
              • + + + + + Using Spark ML with TypedDataset + + + + + +
                • + +
              • @@ -252,7 +265,7 @@

                Example

                // defined class Person val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42,Tue May 23 10:57:10 CEST 2017)) +// people: Seq[Person] = List(Person(42,Wed Oct 18 09:21:38 PDT 2017))

                And an instance of a TypedDataset:

                val personDS = TypedDataset.create(people)
@@ -269,14 +282,14 @@ 
                Example
                
   def apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@6d6cc4bc
+// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@2b4ee43e

                We can be less verbose using the Injection.apply function:

                import frameless._
 // import frameless._
 
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@79ea3da5
+// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@5a548922

                Now we can create our TypedDataset:

                val personDS = TypedDataset.create(people)
@@ -321,7 +334,7 @@ 
                Another example
                
     case 2 => Female
     case 3 => Other
   })
-// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@70fdc07e
+// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@62c73008

                And now we can create our TypedDataset:

                val personDS = TypedDataset.create(people)
@@ -370,7 +383,7 @@ 
                No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"next":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"previous":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Injection.md","mtime":"2017-05-23T08:57:16.378Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-23T08:59:39.758Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"next":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"previous":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Injection.md","mtime":"2017-10-18T16:21:39.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-10-18T16:22:33.699Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/Job.html b/Job.html
index cca8a51be..76839ebab 100644
--- a/Job.html
+++ b/Job.html
@@ -180,7 +180,20 @@
                • -
              • +
              • + + + + + Using Spark ML with TypedDataset + + + + + +
                • + +
              • @@ -240,8 +253,11 @@

                Job[A]

                All operations on TypedDataset are lazy. An operation either returns a new -transformed TypedDataset or a Job[A], where A is the result of running a -non-lazy computation in Spark. Job serves several functions:

                +transformed TypedDataset or an F[A], where F[_] is a type constructor +with an instance of the SparkDelay typeclass and A is the result of running a +non-lazy computation in Spark.

                +

                A default such type constructor called Job is provided by Frameless.

                +

                Job serves several functions:

                Why?

                @@ -348,7 +363,7 @@

                No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"Introduction","level":"1.1","depth":1,"next":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"path":"FeatureOverview.md","ref":"FeatureOverview.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"README.md","mtime":"2017-05-23T08:56:58.442Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-05-23T08:59:39.758Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"Introduction","level":"1.1","depth":1,"next":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"path":"FeatureOverview.md","ref":"FeatureOverview.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"README.md","mtime":"2017-10-18T16:21:41.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-10-18T16:22:33.699Z"},"basePath":".","book":{"language":""}}); }); diff --git a/search_index.json b/search_index.json index 1691f345f..50b381720 100644 --- a/search_index.json +++ b/search_index.json @@ -1 +1 @@ -{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["\"0.3.0\"","\"frameless","\"org.typelevel\"","%","%%","(e.g.","(includ","(peopl","(support","(thumb",")","++=","+1,","+=","0.13.13:","0.9.x)","2.0","2.0,","2.0.x)","2.11.x.","=",">=","add","adelbertc","against","apach","api:","are:","associ","avail","benefit","bootstrap","break","bring","build.sbt","built","cast","cat","cats\"","chang","channel","code","column","compar","compil","concept","concept:","conduct","consist","consol","contribut","contributor","creat","current","custom","customizable,","dataset","dataset\"","depend","develop","document","easi","encod","enhanc","environ","express","featur","few","file","file.","follow","frameless","framelessvers","framelessversion,","friendli","function","g8","get","giter8","github,","gitter)","ground,","http://opensource.org/licenses/apach","imario","imarios/frameless.g8","injection:","insid","instal","introduct","jeremyrsmith","job[a]","kanterov","learning.","librari","librarydepend","licens","list(","load","made","maintain","merg","modules:","more","needed:","new","next","non","note","olivierblanvillain","on","overview","possibl","project","project:","proof","provid","pull","quick","rdd","referenc","requests)","requests.","requir","resolv","resolver.sonatyperepo(\"releases\")","safe","same","sbt","scala","shell","sign","signatur","similar)","simply:","spark","spark'","spark).","spark.","standard","start","still","strongli","support","type","typeddatafram","typeddataset","typeddataset:","typelevel","types.","typesaf","under","up","up,","us","val","veri","versions.","want","way","well","why?","work"],"FeatureOverview.html":["\"false\")","\"paris\")","'`citi`'","'import","'name),","'population)","'price),","'project","(a)","(automated)","(b)","(enjoy","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(in","(lyon,166500.0))","(manual)","(name:","(paris,333333.3333333333),","(string,","(u:","(up","(which","(with",")",").as[aptpricecity].show().run",").as[stats].show().run()","*","+","...","/","//","1","10,","100,","10000.0,","102|","133000.0),","2","2).as[updatedsurface]","2).show().run()","2.0","200000.0),","2229621),","2229621|","2409.6385542168673,","25,","250000.0),","250|","25|[paris,","27|","2955.5555555555557,","300000.0),","325000.0)","343629)","343629|","4391.891891891892)","4391.891891891892|","45,","4500.0,","450000.0),","450|","458","47|","50,","500715),","500715|","500|","52|","6833.333333333333|","74,","740|","76|","83,","830|","85|",":27:",":28:",":31:",":33:",":34:",":36:","=","==","=>","['citi]","[1...10]).","[_1:","[city#206,","[city,","[city:","[lyon,45,133000.0]|","[lyon,500715]|","[lyon,83,200000.0]|","[nice,343629]|","[nice,74,325000.0]|","[paris,25,250000.0]|[paris,2229621]|","[paris,50,300000.0]|[paris,2229621]|","[ratio:","^","_1|","_2:","_2|","abov","achiev","actual","ad","addit","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","agg()","aggreg","aggregated,","agree.","align.","allcities:","allcities|","allow","allowed,","allowed.","alternatives:","and/or","anoth","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartmentdetail","apartmentdetails(city:","apartmentdetails?","api","appear","appli","aptd","aptds('price)","aptds('price)))","aptds('price),","aptds('surface))","aptds('surface)).as[apartmentdetails]","aptds('surface),","aptds.agg(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)).as[updatedsurface]","apttypedds('city),","apttypedds('city).cast[double]","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.join(citiinfotypedds,","apttypedds.makeudf(pricemodifier)","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds2","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","arguments)","as:","as[t]","avail","available.","averag","averageable:","avg(aptds('price)),","avg(aptds('surface)),","avgprice:","avgprice|","avgsurface:","avgsurface|minsurface|","base","better","between","boolean","boolean)].","c:","calcul","can't","case","case.","cast","cast,","catalystcast.","catalystcast[string,","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name))","city:","cityinfo","cityinfo(city:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|surface|","class","class:","claus","clause.","code","collectset(aptds('city))","column","column:","columns:","combin","compil","compile.","compile:","compiles:","complet","comput","computations.","conf","context","continu","correspond","creat","dataset","dataset.","dataset:","defin","detail","directli","discuss","divid","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","each","easili","elid","enabl","enabled.","entir","error","error.","error:","evid","exampl","example,","example.","exist","explan","explicitli","express","extra","featur","few","field","field]","fields]","find","five","follow","form","frameless","frameless.catalystaverageable[string,out]","frameless.catalystcast[string,double]","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.functions.aggregate._","frameless.implicits.widen._","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[apartment,double])(implicit","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","function","gener","get","give","given","groupbi","groupby()","here","here.","here:","however,","id","if(nam","implicit","implicitli","import","inform","initi","input","instanc","instances:","instanti","int","int)","int).","int,","int.","int]","interest","introduc","job","join","language:postfixops.","lazi","lazy.","let'","lift","localrel","long","look","lyon]|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","macro","make","materialize.","math","matter","member","method","method.","min(aptds('surface)),","minimum","minsurface:","misspel","mistak","more","n","n:","name","name:","need","new","next","next,","nice,","nice|","nice|325000.0|","not,","note","now","on","oper","operations:","option","order","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:58)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:77)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$8.apply(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2$1.apply(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionup$1(queryplan.scala:269)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:69)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:308)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:126)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:186)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:307)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:64)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2603)","org.apache.spark.sql.dataset.select(dataset.scala:969)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:49)","org.apache.spark.sql.sparksess","org.apache.spark.{sparkconf,","overload","overview","paramet","particular","per","perform","perhap","popul","population:","postfix","prefer","preserv","price","price#208]","price,","price/surfac","price:","price:double)","price];;","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.collect.run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","proce","project","prove","rais","ratio","ratio:","ratio|","readi","referenc","repl\").set(\"spark.ui.enabled\",","requir","res17:","res6:","res7:","resolv","result","retriev","right?","row","run","run()","safe","safe,","safe.","safety,","safety.","same","scala","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala.language.postfixop","scala.language.postfixops'","scaladoc","see","seem","select","select()","selectmany()","selectmany,","seq(","seq[(string,","seq[double]","set","shapeless.tag.tagged[string(\"citi\")]","shorter","show","show()","simpl","skip","spark","spark.createdataset(apartments)","spark.implicits._","spark.sparkcontext.setloglevel(\"warn\")","spark.sqlcontext","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","sqlcontext","stack","standard","start","stat","stats(","string","string)","string),updatedsurface]","string,","string]","struct,","struct]","subset","suggests,","support","suppos","surfac","surface#207,","surface,","surface,th","surface:","symbol","syntax:","t","tell","ten","three","time","time,","top","trace):","tri","tutori","two","type","type:","typedcolumn","typeddataset","typeddataset.","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","types,","typesaf","typo","u","udf","udf(aptds('city),","udf:","unit:","unlik","unsaf","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","val","valid","valu","vector[string])","visible.","want","warning:","way","wherea","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","work","worked,","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","|","|1000|102|","|276333.3333333333|62.833333333333336|","|4500.0|450000.0|","|6000.0|300000.0|","|[paris,100,450000.0]|[paris,2229621]|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|"],"TypedDatasetVsSparkDataset.html":["\"e\")","\"java.util.date\",","\"jday\")","\"mydate\"","\"q\")","\"w\")","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","&&","'`x`'","'project","(case","(class:","(i#69l","(int,","(isnotnull(i#69l)","(look","(see","(the",")",").explain()",").select(",").show().run()","*batchedscan","*deserializetoobject","*filter","*mapel","*project","*serializefromobject","+",",","...",".appli","//","10","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10|","1|","450","770",":20:",":21:",":22:","::","=","==","===","['x]","[],","[i#69l","[i#69l,j#70]","[i#69l]","[i,","[i:","[input[0,","[isnotnull(i),","^","_1#176l]","_1|","above.","access","achiev","act","ad","allow","api","applications.","area","argument","as[long]","assum","at[long]","avoid","bar","bar(1)))","bar(i:","before.","bigint","bigint))","bigint,","bigint]","bind","both","bug","bulletproof:","captur","case","cast","cast(10","catalyst","class","class:","classes)","clearli","closur","closures.","code","code.","column","columnar","columns,","columns:","compar","comparison,","compil","compromis","content","context","correct.","correctli","creat","current","dataset","dataset.","dataset[long].","datasets,","defin","detail.","detect","differ","discuss","discussion.","disk","doesn't","ds","ds.filter($\"i\"","ds.filter(_.i","ds.show()","ds:","each","elid","encod","encoder:","entir","equalto(i,10)],","error","error:","etc)","exampl","example,","exist","explain","explicitli","express","extrem","e|","fail","failure:","familiar","fd","fds('i)","fds('x)","fds.filter(","fds:","few","field","fields.","file","file.","file:/tmp/foo,","filter","filteredd","filteredds.explain()","filteredds.show()","filteredds:","find","first","first,","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo,","foo.","format","format:","found","frameless","frameless'","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[mydate]","friend.","fulli","function","futur","generated.","give","given","goal:","great!","guard","handhold","help","here","here.","hold","however,","implement","implicit","import","improv","incompat","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","input","inputpaths:","insid","int)","introduc","intuitively,","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date(system.currenttimemillis))))","java.util.date)","j|","know","last","lead","let'","limit","line","linux","load","long","long,","look","mac","map","member","members.","mention","mistak","more","mydat","mydate(jday:","name","name:","need","newinstance(class","next","nil","non","note","notifi","now,","obj#103:","obj#104:","ok","on","oper","optim","optimizer)","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:58)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:77)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:61)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$8.apply(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2$1.apply(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionup$1(queryplan.scala:269)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:592)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:598)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:425)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:69)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:308)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:126)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:186)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:307)","org.apache.spark.sql.dataset.(dataset.scala:161)","org.apache.spark.sql.dataset.(dataset.scala:167)","org.apache.spark.sql.dataset.select(dataset.scala:1023)","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:274)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:49)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:47)","os","paramet","parquet","parquetformat,","partial","partitionfilters:","pass","performance.","physic","plan","plan,","plan.","plan:","popular","practic","primit","problem","problem.","product","product,","provid","pushedfilters:","queri","quick","q|","read","readschema).","readschema:","refer","relation[i#69l,j#70]","releases.","remind","requir","resolv","return","root","run","runtim","safe","safe.","safety!","safety.","save","scala","scala.","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala>","schema","second,","see","select","select()","separately,","serial","serv","set","shapeless.tag.tagged[string(\"x\")]","show","simpl","simplist","slow","small","solut","solv","spark","spark'","spark.","spark.createdataset(","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark:","sparksess","standard","statement","statement).","store","string)","string,","string]","struct","subset","suffici","support","symbol","syntax","syntax.","take","thing","this.","time","time.","time:","togeth","tri","true]","tutori","two","type","type.","typedcolumn","typeddataset","typeddataset.","typeddataset.create(ds)","typeddataset.create(seq(mydate(new","typeddatset","unabl","unfortunately,","us","val","valu","value#105l]","veri","view","want","way","well","without","work","w|","x","x:","|","|100|","|value|"],"TypedEncoder.html":["\"daterange\"","\"java.util.date\",","\"s\")","\"s\"))))","\"s\",","(a","(and","(class:","...","//","2.0)","230",":26:",":28:","=","[i:","^","annoy","approach","around","b:","bar","bar(1.1,","bar(d:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","behav","besid","call","case","class","class:","classes.","code","compil","construct","coupl","current","custom","data","data.","dataset","dataset?.","dataset[daterange]","daterange(s:","decod","defin","deriv","derived,","detect","different,","double,","ds.collect()","ds:","e:","elid","encod","encoder.","encoder:","encoders,","ensur","error","error:","exampl","example,","existence)","expected:","extend","fail","field","find","follow","foo","foo(i:","foodate(i:","found","frameless","frameless.job$$anon$4@8a0bd3c","frameless.job[seq[foo]]","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless:","gener","goe","hierarchi","ident","implicit","implicitli","import","inabl","int,","intern","introduc","issues.","it'","java.lang.unsupportedoperationexception:","java.util.d","java.util.date)","java.util.date)))","java.util.date))))","java.util.date,","jvm","lead","limit","manipul","mechan","method","more","name:","new","non","note","object","onc","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:61)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:592)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:598)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:425)","org.apache.spark.sql.dataset","org.apache.spark.sql.encoders$.product(encoders.scala:274)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:47)","overflow","paramet","pass","performances.","prove","question","recurs","reflect","represent","res2:","resolut","root","run","runtim","s:","same","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala>","scalareflect","schema.","see","shapeless","shown","situat","solv","spark","spark.implicits._","spark:","sqlcontext.createdataset(seq(daterange(new","stack","standard","store","string)","string,","struct]","summari","support","t:","take","thought","time,","time.","time:","trace,","tri","type","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeencod","types.","us","val","valu","vanilla","won't","work"],"Injection.html":["$anon$1@6d6cc4bc","//","1","10:57:10","2","2017))","23","3",":24:",":32:","=","=>","[age:","^","a):","again","anoth","apply(a:","apply(d:","available,","b","b):","b.","b]","bigint]","birthday:","can't,","case","cest","class","class:","compil","creat","custom","d.gettime()","datetolonginject","datetolonginjection:","def","defin","definit","encod","encoder:","error.","error:","exampl","extend","family:","femal","find","frameless._","frameless.injection$$anon$1@70fdc07","frameless.injection$$anon$1@79ea3da5","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.typeddataset[person]","frameless.typedencoder[person]","function:","gender","gender)","gender:","gendertoint:","implicit","import","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","instanc","int,","int]","invert(b:","invert(l:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date)","java.util.date))","java.util.date).gettime(),","java.util.date):","java.util.date.","less","let","let'","list(person(42,male))","list(person(42,tu","long","long)))","long):","long:","long]","look","male","male))","more","new","now","object","on","paramet","peopl","people:","person","person(age:","persond","personds:","precis","seal","seq(person(42,","seq[person]","serializ","simpl","trait","tri","type","type,","typeclass:","typeddataset,","typeddataset.create(people)","typeddataset:","typedencod","us","val","valu","verbos","{","}","})","},"],"Job.html":["(a","(sample:","//","1","20%","20)","=","[_1:","above)","allow","along","annotate/nam","applic","be","block","calcul","collect","compar","complex","compos","composit","comprehens","comput","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","count","countandtakejob","def","description.","differ","driver","ds","ds:","easier","element","elements:","exactli","exampl","execut","expens","explicit","explicitli","few","finaljob","finaljob.","finaljob:","first","frameless.job","frameless.job$$anon$2@2e359e76","frameless.job[int]","frameless.job[seq[int]])frameless.job[int]","frameless.typeddataset[int]","functions:","further","group","have","help","id","import","inform","int","int]","issues.","job","job[a]","job[a],","job[int]","job[seq[int]]):","jobs.","lazi","lazili","lazy,","lazy.","make","min\").","monad","more","new","non","now","obviou","oper","part","pass","perform","place","predict","program","programm","provid","res2:","result","return","run","run()","sample.map(_.min)","say,","see","sequenc","serv","sever","show","showcas","size","spark","spark.","specifi","strict","toy","track","track,","transform","typeddataset","typeddataset.create(1","ui","us","val","via","withdescription(\"sampl","withgroupid(\"samplingjob\").","{"],"Cats.html":["\"task2\"","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(1,","(1,2,3)","(10,9,9)","(8,","(8,2,3)","(and","(chris,map(0","(john,map(0","(sam,map(0","(semigroup)",")","//","1","1)","1))","1)),","1),","1,","10))","10,","100)","11))","12)","12,","15)))","2","2)","2))","2)),","2,","20)","20,","3)","3))","3,","32,","4))","4)),","4,","5,","6,",":21",":22",":24",":26","::","=",">","aggreg","alia","alias","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","anna","arbitrari","arity.","array((joe,map(0","array[(username,","assum","avg,","below","cat","cats.implicits.","cats.implicits._","cats:","class","collect","column","combin","common","complex","comput","data","data.","data:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","default","defin","differ","element","etc.","exampl","example,","example:","execut","follow","frameless.cats.implicits._","frameless.cats.outer._","full","general).","group","implicit","implicits.scala:18","implicits.scala:43","import","int","int)]","int,","joe","join","key","key.","keys.","larg","leverag","makerdd","map(\"task1\"","map(\"task3\"","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[10]","mapvalu","max,","meaning","min,","more","nil","nil)","note","offer","on","oper","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","outer","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","pair","parallelcollectionrdd[0]","parallelcollectionrdd[1]","parallelcollectionrdd[3]","parallelcollectionrdd[5]","parallelcollectionrdd[6]","predicates.","previous","println(data.cmax)","println(data.cmin)","println(data.csum)","rdd","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","reducebykey","res10:","res11:","res7:","res8:","same","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala.collection.immutable.map[string,int])]","scala.collection.map[string,scala.collection.immutable.map[string,int]]","scala.collection.map[user,transactioncount]","section","semigroup","set","show","shuffledrdd[2]","shuffledrdd[4]","simplifi","sort","spark","string","task","task2","task3","timeseri","timeseries)]","together.","totalperus","totalperuser.collectasmap","totalperuser:","transactioncount","transactioncount)]","tupl","type","type.","us","user","user'","usernam","val","valu","way","work","|+|"],"TypedDataFrame.html":["\"dummy\"","\"unique\"","').map(r","'_4)","'q',","'s)","'x',","'z'))","'z'.","(((((((((","(implicit","(phonebooktf:",")",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","//","1.6","1.6+,","1.6,","11","2.10,","2.11","2.11,","22.",":",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","=>","???","addit","address","address,","address:","alphabet:","alternatively,","amount","api","approach","approxim","ariti","avail","away:","b:","bar(i:","be","bestneighborhood","boolean","boolean)","boolean):","boolean)]","boolean,","both","bring","c:","call","case","catch","caus","citi","citymapentry(","citymaptf:","class","column","columns.","come","common","commonli","compar","compat","compil","complet","comput","concept:","consid","consist","contain","conveni","correct","cough","count:","d:","data,","datafram","dataframe,","dataframes,","dataset","def","defin","definit","deprec","design","develop","differ","directli","dive","documented.","domain","done","doubl","double,","due","each","earli","element","enough","ensur","essenti","everyth","exampl","example:","except","execut","exist","expect","f","f.neighborhood))","f.residents.split('","fact","family(residents:","field","filter(conditionexpr:","first","flat","focu","follow","foo(s:","frameless","frameless.","frameless.typeddatafram","frameless:","function","further","futur","get","go","goal","goe","handl","have","here","hold","however,","i:","ident","import","improv","inform","instead","int)","int,","interest","intermedi","introduc","introduct","j:","job","jobs.","join","join1(tf1:","join2(tf1:","joins,","keep","languag","less","let","let'","letter","level","leverag","librari","like,","limit","limitations.","line","long)","long)])","look","main","manag","manipul","manner.","map","mirror","mistak","model","moder","more","much","name","name.exists(set('x',","names,","natur","need","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","nlplib","nlplib.uniquename(p.name)","now","number,","object","obtain","ontypeddataframe.","onward.","org.apache.spark.sql.datafram","org.apache.spark.sql.sqlcontext","p","packag","pair","person(name:","person(r,","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","point,","possibl","process","product.","proof","provid","public","readability.","readabl","reasons,","refer","referenc","represent","residents:","result","rethought","return","right","sadly,","safe","safety.","scala","schema","schema.","second","see","see,","seem","select","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","shadow","shapeless.hlist","signatures:","similar","simplifi","singl","spark","spark'","spark,","sqlcontext):","stage","still","store","string","string):","string)]","string)])","string,","suppos","syntax","syntaxes,","system","systems,","tabl","table,","tables:","target","tdataframe[schema","tdataframe[schema]","techniqu","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","time.","track","troubl","tuple23","two","type","type,","type.","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry]","typeddataframe[citymapentry])","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","types:","typo,","uniqu","uniquename(name:","us","user","valu","vanilla","variou","veri","version","way","well,","won't","work","zero.","{","}"]},"length":8},"tokenStore":{"root":{"0":{"docs":{},".":{"1":{"3":{"docs":{},".":{"1":{"3":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"docs":{}},"docs":{}}},"docs":{}},"9":{"docs":{},".":{"docs":{},"x":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}},"docs":{}}},"1":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"i":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}},":":{"5":{"7":{"docs":{},":":{"1":{"0":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.017391304347826087}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.013043478260869565}}},".":{"6":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"+":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"docs":{}}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"1":{"7":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"docs":{}},"docs":{},"%":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"3":{"0":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"4":{"0":{"9":{"docs":{},".":{"6":{"3":{"8":{"5":{"5":{"4":{"2":{"1":{"6":{"8":{"6":{"7":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"9":{"5":{"5":{"docs":{},".":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},".":{"docs":{},"x":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"1":{"0":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{},"x":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"docs":{}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}}}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"4":{"3":{"6":{"2":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"4":{"3":{"9":{"1":{"docs":{},".":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"8":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"6":{"8":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"7":{"4":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"7":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"docs":{}},"docs":{}},"8":{"3":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{},"\"":{"0":{"docs":{},".":{"3":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"docs":{}}},"docs":{}}},"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"q":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"w":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"y":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"2":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"docs":{}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"%":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}},"%":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}}},"(":{"1":{"0":{"docs":{},",":{"9":{"docs":{},",":{"9":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}},"docs":{}}},"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"8":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"y":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}},"t":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"#":{"6":{"9":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}},"docs":{}},"docs":{}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"6":{"9":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}},"e":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"b":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"1":{"6":{"6":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"u":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}}}},"\"":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}}}}},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}}}}},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}}},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}},"+":{"1":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0622906898861353},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.04267589388696655}},"+":{"docs":{},"=":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"=":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"=":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.03415941058271936},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01384083044982699},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.024922118380062305},"Injection.html":{"ref":"Injection.html","tf":0.06349206349206349},"Job.html":{"ref":"Job.html","tf":0.040229885057471264},"Cats.html":{"ref":"Cats.html","tf":0.05217391304347826},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.016605166051660517}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.011534025374855825}},"=":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495}}}},">":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}},">":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.08695652173913043}},"=":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"e":{"docs":{},"l":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"d":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}},"s":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"3":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"(":{"docs":{},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"[":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},"e":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"b":{"docs":{},"o":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Job.html":{"ref":"Job.html","tf":0.017241379310344827}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"n":{"docs":{},"o":{"docs":{},"y":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"t":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"b":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"docs":{}}},"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"(":{"1":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"docs":{}},"docs":{}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007367716008037508},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.024922118380062305},"Injection.html":{"ref":"Injection.html","tf":0.04126984126984127},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01845018450184502}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.018604651162790697},"Cats.html":{"ref":"Cats.html","tf":3.339855072463768}},"s":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"u":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012915129151291513}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.502306805074971},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"x":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}}}}}},"o":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351783517835174}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"o":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Injection.html":{"ref":"Injection.html","tf":2.5126984126984127}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":2.503174603174603}},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.010716677829872739},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010380622837370242},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03426791277258567},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.02214022140221402}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"u":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.018604651162790697},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5092272202998847},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"\"":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"?":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012915129151291513}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}}}}}}}}},"y":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"f":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014760147601476014}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.03492063492063492},"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018691588785046728}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"e":{"docs":{},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"_":{"docs":{},".":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.021806853582554516},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"u":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.013953488372093023},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3551401869158877},"Injection.html":{"ref":"Injection.html","tf":2.5126984126984127}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"s":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"t":{"docs":{},"i":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"s":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"i":{"docs":{},",":{"1":{"0":{"docs":{},")":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"docs":{}},"docs":{}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.334672918062067}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}},":":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}}},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},"a":{"docs":{},"l":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"c":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.04186046511627907},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3426791277258565},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}}}}}}}}}}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"7":{"0":{"docs":{},"f":{"docs":{},"d":{"docs":{},"c":{"0":{"7":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"docs":{}},"docs":{}}}}},"9":{"docs":{},"e":{"docs":{},"a":{"3":{"docs":{},"d":{"docs":{},"a":{"5":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"docs":{}}}},"docs":{}}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"2":{"docs":{},"@":{"2":{"docs":{},"e":{"3":{"5":{"9":{"docs":{},"e":{"7":{"6":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"4":{"docs":{},"@":{"8":{"docs":{},"a":{"0":{"docs":{},"b":{"docs":{},"d":{"3":{"docs":{},"c":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"_":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}}}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"s":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}},"l":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495}}}},"x":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"l":{"docs":{},")":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015873015873015872}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}}},"t":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"8":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},"docs":{}}},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"p":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"b":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}},"o":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"a":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"l":{"docs":{},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"v":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"s":{"docs":{},"/":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}},"docs":{}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152},"Injection.html":{"ref":"Injection.html","tf":0.015873015873015872},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"docs":{}},"4":{"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{}},"docs":{}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008707300736771601},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008073817762399077},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.017391304347826087},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015873015873015872}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"Injection.html":{"ref":"Injection.html","tf":2.503174603174603}}},"(":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},"n":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"t":{"docs":{"./":{"ref":"./","tf":10},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{},"h":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"l":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"f":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"t":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"j":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"y":{"docs":{},"r":{"docs":{},"s":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.022988505747126436},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"Job.html":{"ref":"Job.html","tf":10.005747126436782}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"n":{"1":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}}}}},"2":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01107011070110701}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"l":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.01557632398753894}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"v":{"docs":{},"m":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"e":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"s":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}}}}},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.018604651162790697}}}}}},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}},"t":{"docs":{},"u":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"docs":{}},"docs":{}}}}}}}}}}},"f":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"u":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"o":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},":":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"z":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"y":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"r":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"8":{"2":{"docs":{},".":{"5":{"9":{"7":{"0":{"5":{"4":{"8":{"8":{"6":{"2":{"1":{"1":{"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"m":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"r":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"Job.html":{"ref":"Job.html","tf":0.022988505747126436}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.010869565217391304}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.013043478260869565}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}},"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}},"3":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"docs":{}}}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"0":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"n":{"docs":{},"i":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"e":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"x":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"e":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007367716008037508},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"Job.html":{"ref":"Job.html","tf":0.011494252873563218},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"a":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"u":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"s":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},"e":{"docs":{},"(":{"docs":{},"j":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018691588785046728},"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}},"x":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"t":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"v":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}}}}}}}}}}},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"c":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3340031256977003}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Job.html":{"ref":"Job.html","tf":0.028735632183908046},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00922722029988466}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"$":{"2":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"7":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"8":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"2":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"2":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"$":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"0":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"0":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"9":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"8":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"9":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"8":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"9":{"8":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},"$":{"docs":{},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"$":{"docs":{},"$":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"0":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"2":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}},"9":{"6":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"6":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"$":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"{":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},".":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"j":{"docs":{},"#":{"1":{"0":{"3":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.018604651162790697},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"o":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351783517835174}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}},"#":{"2":{"0":{"8":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"/":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"b":{"docs":{},"y":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}}}}}}}}},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"3":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.009302325581395349}}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"0":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"1":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"3":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"5":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"6":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}},"i":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.012687427912341407}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"i":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"s":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}},"(":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905}},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"t":{"docs":{},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"c":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"Cats.html":{"ref":"Cats.html","tf":3.3376811594202898}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"i":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}}}},"s":{"1":{"0":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"1":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"2":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"8":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"a":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"u":{"docs":{},"i":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"#":{"6":{"9":{"docs":{},"l":{"docs":{},",":{"docs":{},"j":{"docs":{},"#":{"7":{"0":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003348961821835231}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}},"o":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"m":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"y":{"docs":{},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"d":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.018604651162790697}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"5":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"9":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"f":{"docs":{},"i":{"docs":{},"x":{"docs":{},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"s":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},">":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"2":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"4":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"docs":{}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}},"y":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}},"z":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.018604651162790697},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01384083044982699},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009345794392523364},"Job.html":{"ref":"Job.html","tf":0.034482758620689655},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01845018450184502}},"'":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5046136101499425},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},")":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"[":{"docs":{},"*":{"docs":{},"]":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}},"g":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}},",":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.014735432016075016},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014760147601476014}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"#":{"2":{"0":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007367716008037508}}}}}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"[":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.017241379310344827}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"i":{"docs":{},"z":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.018604651162790697},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.010046885465505693},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0196078431372549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.345794392523364},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Cats.html":{"ref":"Cats.html","tf":0.02391304347826087},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.027675276752767528}},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.34440344403444}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"p":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.009302325581395349},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5034602076124566},"Job.html":{"ref":"Job.html","tf":0.022988505747126436}},":":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3353427104264344},"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}},"docs":{}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.01904761904761905}}}}}}}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"[":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}},"u":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576}}}}}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"a":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.013953488372093023},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012461059190031152}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}}}}},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008695652173913044}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.009523809523809525}}}},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},"u":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}},"p":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},"e":{"2":{"3":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"docs":{}},"docs":{}}}}},"w":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"s":{"docs":{},"k":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}},"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}}},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}},"f":{"1":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"j":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"2":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"j":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}},"i":{"docs":{},"t":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}}}},"p":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}},",":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{"./":{"ref":"./","tf":0.027906976744186046},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006920415224913495},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746},"Job.html":{"ref":"Job.html","tf":0.017241379310344827},"Cats.html":{"ref":"Cats.html","tf":3.339855072463768},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.00922509225092251}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"'":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}}}}}}}},"d":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.011494252873563218}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.018754186202277295},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0057670126874279125},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018691588785046728},"Injection.html":{"ref":"Injection.html","tf":0.03492063492063492},"Job.html":{"ref":"Job.html","tf":0.017241379310344827},"Cats.html":{"ref":"Cats.html","tf":0.017391304347826087}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004018754186202277},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},"#":{"1":{"0":{"5":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"docs":{}},"docs":{}},"docs":{}}}}},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}}},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"a":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0053583389149363695},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"y":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"h":{"docs":{},"y":{"docs":{},"?":{"docs":{"./":{"ref":"./","tf":0.004651162790697674}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.004651162790697674},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"(":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"'":{"docs":{},"`":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"x":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"_":{"4":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"q":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"z":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"*":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}},"b":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006028131279303416},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"_":{"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"docs":{}}}}}}},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.12391158740790355},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.08419838523644751},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03115264797507788},"Injection.html":{"ref":"Injection.html","tf":0.06666666666666667},"Job.html":{"ref":"Job.html","tf":0.028735632183908046},"Cats.html":{"ref":"Cats.html","tf":0.05},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},":":{"2":{"0":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"4":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002173913043478261}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"6":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004347826086956522}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}}},"docs":{}},"3":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"2":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"4":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}},"docs":{}},"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475},"Cats.html":{"ref":"Cats.html","tf":0.0391304347826087}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"[":{"1":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"1":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}},"docs":{}},"docs":{}}}}},"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}},"x":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"_":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004688546550569324},"Job.html":{"ref":"Job.html","tf":0.005747126436781609}}}},"docs":{}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"#":{"2":{"0":{"6":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006697923643670462}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"4":{"5":{"docs":{},",":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0013395847287340924}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"8":{"3":{"docs":{},",":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"4":{"3":{"6":{"2":{"9":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"7":{"4":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"5":{"docs":{},",":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"5":{"0":{"docs":{},",":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}}}}},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233}}}},"i":{"docs":{},"#":{"6":{"9":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},",":{"docs":{},"j":{"docs":{},"#":{"7":{"0":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0034602076124567475}}}}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003115264797507788}}},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"[":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}}}}}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}}}}}},"^":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008037508372404554},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00461361014994233},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006230529595015576},"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349}}},"_":{"1":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"#":{"1":{"7":{"6":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}},"docs":{}},"docs":{}},"docs":{}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0026791694574681848}}}},"docs":{}},"|":{"1":{"0":{"0":{"0":{"docs":{},"|":{"1":{"0":{"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"docs":{}},"docs":{}},"2":{"7":{"6":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"6":{"2":{"docs":{},".":{"8":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.01808439383791025},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00922722029988466}},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"1":{"0":{"0":{"docs":{},",":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006697923643670462}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0020093770931011385}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}},"+":{"docs":{},"|":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006521739130434782}}}}},"$":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"1":{"4":{"docs":{},".":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"6":{"docs":{},"d":{"6":{"docs":{},"c":{"docs":{},"c":{"4":{"docs":{},"b":{"docs":{},"c":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}}},"docs":{}}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}},"&":{"docs":{},"&":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002306805074971165}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011534025374855825}}}},"{":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012698412698412698},"Job.html":{"ref":"Job.html","tf":0.005747126436781609},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},"}":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006349206349206349},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031746031746031746}}}},"?":{"docs":{},"?":{"docs":{},"?":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"length":2211},"corpusTokens":["\"0.3.0\"","\"daterange\"","\"dummy\"","\"e\")","\"false\")","\"frameless","\"java.util.date\",","\"jday\")","\"mydate\"","\"org.typelevel\"","\"paris\")","\"q\")","\"s\")","\"s\"))))","\"s\",","\"task2\"","\"unique\"","\"w\")","$anon$1@6d6cc4bc","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","%","%%","&&","').map(r","'_4)","'`citi`'","'`x`'","'import","'name),","'population)","'price),","'project","'q',","'s)","'x',","'z'))","'z'.","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(((((((((","(1,","(1,2,3)","(10,9,9)","(8,","(8,2,3)","(a","(a)","(and","(automated)","(b)","(case","(chris,map(0","(class:","(e.g.","(enjoy","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(i#69l","(implicit","(in","(includ","(int,","(isnotnull(i#69l)","(john,map(0","(look","(lyon,166500.0))","(manual)","(name:","(paris,333333.3333333333),","(peopl","(phonebooktf:","(sam,map(0","(sample:","(see","(semigroup)","(string,","(support","(the","(thumb","(u:","(up","(which","(with",")",").as[aptpricecity].show().run",").as[stats].show().run()",").explain()",").select(",").show().run()","*","*batchedscan","*deserializetoobject","*filter","*mapel","*project","*serializefromobject","+","++=","+1,","+=",",","...",".appli",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","/","//","0.13.13:","0.9.x)","1","1)","1))","1)),","1),","1,","1.6","1.6+,","1.6,","10","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10,","100)","100,","10000.0,","102|","10:57:10","10|","11","11))","12)","12,","133000.0),","15)))","1|","2","2)","2))","2)),","2).as[updatedsurface]","2).show().run()","2,","2.0","2.0)","2.0,","2.0.x)","2.10,","2.11","2.11,","2.11.x.","20%","20)","20,","200000.0),","2017))","22.","2229621),","2229621|","23","230","2409.6385542168673,","25,","250000.0),","250|","25|[paris,","27|","2955.5555555555557,","3","3)","3))","3,","300000.0),","32,","325000.0)","343629)","343629|","4))","4)),","4,","4391.891891891892)","4391.891891891892|","45,","450","4500.0,","450000.0),","450|","458","47|","5,","50,","500715),","500715|","500|","52|","6,","6833.333333333333|","74,","740|","76|","770","83,","830|","85|",":",":20:",":21",":21:",":22",":22:",":24",":24:",":26",":26:",":27:",":28:",":31:",":32:",":33:",":34:",":36:","::",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","==","===","=>",">",">=","???","['citi]","['x]","[1...10]).","[],","[_1:","[age:","[city#206,","[city,","[city:","[i#69l","[i#69l,j#70]","[i#69l]","[i,","[i:","[input[0,","[isnotnull(i),","[lyon,45,133000.0]|","[lyon,500715]|","[lyon,83,200000.0]|","[nice,343629]|","[nice,74,325000.0]|","[paris,25,250000.0]|[paris,2229621]|","[paris,50,300000.0]|[paris,2229621]|","[ratio:","^","_1#176l]","_1|","_2:","_2|","a):","abov","above)","above.","access","achiev","act","actual","ad","add","addit","address","address,","address:","adelbertc","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","against","agg()","aggreg","aggregated,","agree.","alia","alias","align.","allcities:","allcities|","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","allowed,","allowed.","along","alphabet:","alternatively,","alternatives:","amount","and/or","anna","annotate/nam","annoy","anoth","apach","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartmentdetail","apartmentdetails(city:","apartmentdetails?","api","api:","appear","appli","applic","applications.","apply(a:","apply(d:","approach","approxim","aptd","aptds('price)","aptds('price)))","aptds('price),","aptds('surface))","aptds('surface)).as[apartmentdetails]","aptds('surface),","aptds.agg(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)).as[updatedsurface]","apttypedds('city),","apttypedds('city).cast[double]","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.join(citiinfotypedds,","apttypedds.makeudf(pricemodifier)","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds2","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","are:","area","argument","arguments)","ariti","arity.","around","array((joe,map(0","array[(username,","as:","as[long]","as[t]","associ","assum","at[long]","avail","available,","available.","averag","averageable:","avg(aptds('price)),","avg(aptds('surface)),","avg,","avgprice:","avgprice|","avgsurface:","avgsurface|minsurface|","avoid","away:","b","b):","b.","b:","b]","bar","bar(1)))","bar(1.1,","bar(d:","bar(i:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","before.","behav","below","benefit","besid","bestneighborhood","better","between","bigint","bigint))","bigint,","bigint]","bind","birthday:","block","boolean","boolean)","boolean):","boolean)]","boolean)].","boolean,","bootstrap","both","break","bring","bug","build.sbt","built","bulletproof:","c:","calcul","call","can't","can't,","captur","case","case.","cast","cast(10","cast,","cat","catalyst","catalystcast.","catalystcast[string,","catch","cats\"","cats.implicits.","cats.implicits._","cats:","caus","cest","chang","channel","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name))","city:","cityinfo","cityinfo(city:","citymapentry(","citymaptf:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|surface|","class","class:","classes)","classes.","claus","clause.","clearli","closur","closures.","code","code.","collect","collectset(aptds('city))","column","column:","columnar","columns,","columns.","columns:","combin","come","common","commonli","compar","comparison,","compat","compil","compile.","compile:","compiles:","complet","complex","compos","composit","comprehens","compromis","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","concept","concept:","conduct","conf","consid","consist","consol","construct","contain","content","context","continu","contribut","contributor","conveni","correct","correct.","correctli","correspond","cough","count","count:","countandtakejob","coupl","creat","current","custom","customizable,","d.gettime()","d:","data","data,","data.","data:","datafram","dataframe,","dataframes,","dataset","dataset\"","dataset.","dataset:","dataset?.","dataset[daterange]","dataset[long].","datasets,","daterange(s:","datetolonginject","datetolonginjection:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","decod","def","default","defin","definit","depend","deprec","deriv","derived,","description.","design","detail","detail.","detect","develop","differ","different,","directli","discuss","discussion.","disk","dive","divid","document","documented.","doesn't","domain","done","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","ds","ds.collect()","ds.filter($\"i\"","ds.filter(_.i","ds.show()","ds:","due","e:","each","earli","easi","easier","easili","element","elements:","elid","enabl","enabled.","encod","encoder.","encoder:","encoders,","enhanc","enough","ensur","entir","environ","equalto(i,10)],","error","error.","error:","essenti","etc)","etc.","everyth","evid","exactli","exampl","example,","example.","example:","except","execut","exist","existence)","expect","expected:","expens","explain","explan","explicit","explicitli","express","extend","extra","extrem","e|","f","f.neighborhood))","f.residents.split('","fact","fail","failure:","familiar","family(residents:","family:","fd","fds('i)","fds('x)","fds.filter(","fds:","featur","femal","few","field","field]","fields.","fields]","file","file.","file:/tmp/foo,","filter","filter(conditionexpr:","filteredd","filteredds.explain()","filteredds.show()","filteredds:","finaljob","finaljob.","finaljob:","find","first","first,","five","flat","focu","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo(s:","foo,","foo.","foodate(i:","form","format","format:","found","frameless","frameless'","frameless.","frameless._","frameless.catalystaverageable[string,out]","frameless.catalystcast[string,double]","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.cats.implicits._","frameless.cats.outer._","frameless.functions.aggregate._","frameless.implicits.widen._","frameless.injection$$anon$1@70fdc07","frameless.injection$$anon$1@79ea3da5","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.job","frameless.job$$anon$2@2e359e76","frameless.job$$anon$4@8a0bd3c","frameless.job[int]","frameless.job[seq[foo]]","frameless.job[seq[int]])frameless.job[int]","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[apartment,double])(implicit","frameless.typeddatafram","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[foo]","frameless.typeddataset[int]","frameless.typeddataset[person]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless.typedencoder[mydate]","frameless.typedencoder[person]","frameless:","framelessvers","framelessversion,","friend.","friendli","full","fulli","function","function:","functions:","further","futur","g8","gender","gender)","gender:","gendertoint:","gener","general).","generated.","get","giter8","github,","gitter)","give","given","go","goal","goal:","goe","great!","ground,","group","groupbi","groupby()","guard","handhold","handl","have","help","here","here.","here:","hierarchi","hold","however,","http://opensource.org/licenses/apach","i:","id","ident","if(nam","imario","imarios/frameless.g8","implement","implicit","implicitli","implicits.scala:18","implicits.scala:43","import","improv","inabl","incompat","inform","initi","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","input","inputpaths:","insid","instal","instanc","instances:","instanti","instead","int","int)","int).","int)]","int,","int.","int]","interest","intermedi","intern","introduc","introduct","intuitively,","invert(b:","invert(l:","issues.","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date(system.currenttimemillis))))","java.util.date)","java.util.date))","java.util.date)))","java.util.date))))","java.util.date).gettime(),","java.util.date):","java.util.date,","java.util.date.","jeremyrsmith","job","job[a]","job[a],","job[int]","job[seq[int]]):","jobs.","joe","join","join1(tf1:","join2(tf1:","joins,","jvm","j|","kanterov","keep","key","key.","keys.","know","languag","language:postfixops.","larg","last","lazi","lazili","lazy,","lazy.","lead","learning.","less","let","let'","letter","level","leverag","librari","librarydepend","licens","lift","like,","limit","limitations.","line","linux","list(","list(person(42,male))","list(person(42,tu","load","localrel","long","long)","long)))","long):","long)])","long,","long:","long]","look","lyon]|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","mac","macro","made","main","maintain","make","makerdd","male","male))","manag","manipul","manner.","map","map(\"task1\"","map(\"task3\"","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[10]","mapvalu","materialize.","math","matter","max,","meaning","mechan","member","members.","mention","merg","method","method.","min\").","min(aptds('surface)),","min,","minimum","minsurface:","mirror","misspel","mistak","model","moder","modules:","monad","more","much","mydat","mydate(jday:","n","n:","name","name.exists(set('x',","name:","names,","natur","need","needed:","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","new","newinstance(class","next","next,","nice,","nice|","nice|325000.0|","nil","nil)","nlplib","nlplib.uniquename(p.name)","non","not,","note","notifi","now","now,","number,","obj#103:","obj#104:","object","obtain","obviou","offer","ok","olivierblanvillain","on","onc","ontypeddataframe.","onward.","oper","operations:","optim","optimizer)","option","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:58)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:77)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:74)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:67)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:61)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$8.apply(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2$1.apply(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$2(queryplan.scala:283)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:288)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionup$1(queryplan.scala:269)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$9.apply(scalareflection.scala:592)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:583)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:598)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:425)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:69)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:308)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:126)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:186)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:307)","org.apache.spark.sql.datafram","org.apache.spark.sql.dataset","org.apache.spark.sql.dataset$.ofrows(dataset.scala:64)","org.apache.spark.sql.dataset.(dataset.scala:161)","org.apache.spark.sql.dataset.(dataset.scala:167)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2603)","org.apache.spark.sql.dataset.select(dataset.scala:1023)","org.apache.spark.sql.dataset.select(dataset.scala:969)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:274)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:49)","org.apache.spark.sql.sparksess","org.apache.spark.sql.sqlcontext","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:47)","org.apache.spark.{sparkconf,","os","outer","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","overflow","overload","overview","p","packag","pair","parallelcollectionrdd[0]","parallelcollectionrdd[1]","parallelcollectionrdd[3]","parallelcollectionrdd[5]","parallelcollectionrdd[6]","paramet","parquet","parquetformat,","part","partial","particular","partitionfilters:","pass","peopl","people:","per","perform","performance.","performances.","perhap","person","person(age:","person(name:","person(r,","persond","personds:","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","physic","place","plan","plan,","plan.","plan:","point,","popul","popular","population:","possibl","postfix","practic","precis","predicates.","predict","prefer","preserv","previous","price","price#208]","price,","price/surfac","price:","price:double)","price];;","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.collect.run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","primit","println(data.cmax)","println(data.cmin)","println(data.csum)","problem","problem.","proce","process","product","product,","product.","program","programm","project","project:","proof","prove","provid","public","pull","pushedfilters:","queri","question","quick","q|","rais","ratio","ratio:","ratio|","rdd","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","read","readability.","readabl","readi","readschema).","readschema:","reasons,","recurs","reducebykey","refer","referenc","reflect","relation[i#69l,j#70]","releases.","remind","repl\").set(\"spark.ui.enabled\",","represent","requests)","requests.","requir","res10:","res11:","res17:","res2:","res6:","res7:","res8:","residents:","resolut","resolv","resolver.sonatyperepo(\"releases\")","result","rethought","retriev","return","right","right?","root","row","run","run()","runtim","s:","sadly,","safe","safe,","safe.","safety!","safety,","safety.","same","sample.map(_.min)","save","say,","sbt","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala","scala.","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.immutable.map[string,int])]","scala.collection.map[string,scala.collection.immutable.map[string,int]]","scala.collection.map[user,transactioncount]","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala.language.postfixop","scala.language.postfixops'","scala>","scaladoc","scalareflect","schema","schema.","seal","second","second,","section","see","see,","seem","select","select()","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","selectmany()","selectmany,","semigroup","separately,","seq(","seq(person(42,","seq[(string,","seq[double]","seq[person]","sequenc","serial","serializ","serv","set","sever","shadow","shapeless","shapeless.hlist","shapeless.tag.tagged[string(\"citi\")]","shapeless.tag.tagged[string(\"x\")]","shell","shorter","show","show()","showcas","shown","shuffledrdd[2]","shuffledrdd[4]","sign","signatur","signatures:","similar","similar)","simpl","simplifi","simplist","simply:","singl","situat","size","skip","slow","small","solut","solv","sort","spark","spark'","spark).","spark,","spark.","spark.createdataset(","spark.createdataset(apartments)","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark.sparkcontext.setloglevel(\"warn\")","spark.sqlcontext","spark:","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparksess","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","sqlcontext","sqlcontext):","sqlcontext.createdataset(seq(daterange(new","stack","stage","standard","start","stat","statement","statement).","stats(","still","store","strict","string","string)","string),updatedsurface]","string):","string)]","string)])","string,","string]","strongli","struct","struct,","struct]","subset","suffici","suggests,","summari","support","suppos","surfac","surface#207,","surface,","surface,th","surface:","symbol","syntax","syntax.","syntax:","syntaxes,","system","systems,","t","t:","tabl","table,","tables:","take","target","task","task2","task3","tdataframe[schema","tdataframe[schema]","techniqu","tell","ten","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","thing","this.","thought","three","time","time,","time.","time:","timeseri","timeseries)]","togeth","together.","top","totalperus","totalperuser.collectasmap","totalperuser:","toy","trace):","trace,","track","track,","trait","transactioncount","transactioncount)]","transform","tri","troubl","true]","tupl","tuple23","tutori","two","type","type,","type.","type:","typeclass:","typedcolumn","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry]","typeddataframe[citymapentry])","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","typeddataset","typeddataset,","typeddataset.","typeddataset.create(1","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset.create(ds)","typeddataset.create(people)","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset.create(seq(mydate(new","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","typeddatset","typedencod","typeencod","typelevel","types,","types.","types:","typesaf","typo","typo,","u","udf","udf(aptds('city),","udf:","ui","unabl","under","unfortunately,","uniqu","uniquename(name:","unit:","unlik","unsaf","up","up,","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","user'","usernam","val","valid","valu","value#105l]","vanilla","variou","vector[string])","verbos","veri","version","versions.","via","view","visible.","want","warning:","way","well","well,","wherea","why?","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withdescription(\"sampl","withgroupid(\"samplingjob\").","without","won't","work","worked,","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","w|","x","x:","zero.","{","|","|+|","|1000|102|","|100|","|276333.3333333333|62.833333333333336|","|4500.0|450000.0|","|6000.0|300000.0|","|[paris,100,450000.0]|[paris,2229621]|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|value|","}","})","},"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"Introduction","keywords":"","body":"Frameless\n\n\n\n\nFrameless is a proof-of-concept library for working with Spark using more expressive types.\nIt consists of the following modules:\n\ndataset for more strongly typed Datasets (supports Spark 2.0.x)\ncats for using Spark with cats (supports Cats 0.9.x)\n\nThe Frameless project and contributors support the\nTypelevel Code of Conduct and want all its\nassociated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning.\nDocumentation\n\nTypedDataset: Feature Overview\nComparing TypedDatasets with Spark's Datasets\nTyped Encoders in Frameless\nInjection: Creating Custom Encoders\nJob[A]\nUsing Cats with RDDs\nProof of Concept: TypedDataFrame\n\nWhy?\nBenefits of using TypedDataset compared to the standard Spark Dataset API:\n\nTypesafe columns referencing and expressions\nCustomizable, typesafe encoders\nTypesafe casting and projections\nEnhanced type signature for some built-in functions\n\nQuick Start\nFrameless is compiled against Scala 2.11.x.\nNote that while Frameless is still getting off the ground, it is very possible that breaking changes will be\nmade for at least the next few versions.\nTo use Frameless in your project add the following in your build.sbt file as needed:\nresolvers += Resolver.sonatypeRepo(\"releases\")\n\nval framelessVersion = \"0.3.0\"\n\nlibraryDependencies ++= List(\n \"org.typelevel\" %% \"frameless-cats\" % framelessVersion,\n \"org.typelevel\" %% \"frameless-dataset\" % framelessVersion\n)\n\nAn easy way to bootstrap a Frameless sbt project:\n\nif you have Giter8 installed then simply:\n\ng8 imarios/frameless.g8\n\n\nwith sbt >= 0.13.13:\n\nsbt new imarios/frameless.g8\n\nTyping sbt console inside your project will bring up a shell with Frameless\nand all its dependencies loaded (including Spark).\nDevelopment\nWe require at least one sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers\n(people who can merge pull requests) are:\n\nadelbertc\nimarios\njeremyrsmith\nkanterov\nnon\nOlivierBlanvillain\n\nLicense\nCode is provided under the Apache 2.0 license available at http://opensource.org/licenses/Apache-2.0,\nas well as in the LICENSE file. This is the same license used as Spark.\n"},"FeatureOverview.html":{"url":"FeatureOverview.html","title":"TypedDataset: Feature Overview","keywords":"","body":"TypedDataset: Feature Overview\nThis tutorial introduces TypedDataset using a simple example.\nThe following imports are needed to make all code examples compile.\nimport org.apache.spark.{SparkConf, SparkContext}\nimport org.apache.spark.sql.SparkSession\nimport frameless.functions.aggregate._\nimport frameless.TypedDataset\n\nval conf = new SparkConf().setMaster(\"local[*]\").setAppName(\"frameless repl\").set(\"spark.ui.enabled\", \"false\")\nval spark = SparkSession.builder().config(conf).appName(\"REPL\").getOrCreate()\nimplicit val sqlContext = spark.sqlContext\nspark.sparkContext.setLogLevel(\"WARN\")\n\nimport spark.implicits._\n\nCreating TypedDataset instances\nWe start by defining a case class:\ncase class Apartment(city: String, surface: Int, price: Double)\n\nAnd few Apartment instances:\nval apartments = Seq(\n Apartment(\"Paris\", 50, 300000.0),\n Apartment(\"Paris\", 100, 450000.0),\n Apartment(\"Paris\", 25, 250000.0),\n Apartment(\"Lyon\", 83, 200000.0),\n Apartment(\"Lyon\", 45, 133000.0),\n Apartment(\"Nice\", 74, 325000.0)\n)\n\nWe are now ready to instantiate a TypedDataset[Apartment]:\nval aptTypedDs = TypedDataset.create(apartments)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nWe can also create one from an existing Spark Dataset:\nval aptDs = spark.createDataset(apartments)\n// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nval aptTypedDs = TypedDataset.create(aptDs)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nOr use the Frameless syntax:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval aptTypedDs2 = aptDs.typed\n// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nTypesafe column referencing\nThis is how we select a particular column from a TypedDataset:\nval cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))\n// cities: frameless.TypedDataset[String] = [_1: string]\n\nThis is completely type-safe, for instance suppose we misspell city as citi:\naptTypedDs.select(aptTypedDs('citi))\n// :28: error: No column Symbol with shapeless.tag.Tagged[String(\"citi\")] of type A in Apartment\n// aptTypedDs.select(aptTypedDs('citi))\n// ^\n\nThis gets raised at compile-time, whereas with the standard Dataset API the error appears at run-time (enjoy the stack trace):\naptDs.select('citi)\n// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [city, surface, price];;\n// 'Project ['citi]\n// +- LocalRelation [city#206, surface#207, price#208]\n// \n// at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:77)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:74)\n// at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n// at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n// at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:69)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:307)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionUp$1(QueryPlan.scala:269)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:279)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2$1.apply(QueryPlan.scala:283)\n// at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n// at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n// at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)\n// at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)\n// at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n// at scala.collection.AbstractTraversable.map(Traversable.scala:104)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:283)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$8.apply(QueryPlan.scala:288)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:186)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:288)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:74)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:67)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:126)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:67)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:58)\n// at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:49)\n// at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:64)\n// at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2603)\n// at org.apache.spark.sql.Dataset.select(Dataset.scala:969)\n// ... 458 elided\n\nselect() supports arbitrary column operations:\naptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()\n// +----+---+\n// | _1| _2|\n// +----+---+\n// | 500| 52|\n// |1000|102|\n// | 250| 27|\n// | 830| 85|\n// | 450| 47|\n// | 740| 76|\n// +----+---+\n//\n\nNote that unlike the standard Spark API where some operations are lazy and some are not, TypedDatasets have all operations to be lazy. \nIn the above example, show() is lazy. It requires to apply run() for the show job to materialize.\nA more detailed explanation of Job is given here.\nNext we compute the price by surface unit:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// :27: error: overloaded method value / with alternatives:\n// (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] \n// (u: frameless.TypedColumn[Apartment,Double])(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double]\n// cannot be applied to (frameless.TypedColumn[Apartment,Int])\n// val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// ^\n\nAs the error suggests, we can't divide a TypedColumn of Double by Int. \nFor safety, in Frameless only math operations between same types is allowed. \nThere are two ways to proceed here: \n(a) Explicitly cast Int to Double (manual)\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect().run()\n// res6: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\n(b) Perform the cast implicitly (automated)\nimport frameless.implicits.widen._\n// import frameless.implicits.widen._\n\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect.run()\n// res7: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\nLooks like it worked, but that cast seems unsafe right? Actually it is safe.\nLet's try to cast a TypedColumn of String to Double:\naptTypedDs('city).cast[Double]\n// :31: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]\n// aptTypedDs('city).cast[Double]\n// ^\n\nThe compile-time error tells us that to perform the cast, an evidence \n(in the form of CatalystCast[String, Double]) must be available. \nSince casting from String to Double is not allowed, this results \nin a compilation error. \nCheck here \nfor the set of available CatalystCast.\nTypeSafe TypedDataset casting and projections\nWith select() the resulting TypedDataset is of type TypedDataset[TupleN[...]] (with N in [1...10]).\nFor example, if we select three columns with types String, Int, and Boolean the result will have type\nTypedDataset[(String, Int, Boolean)]. To select more than ten columns use the selectMany() method. \nSelect has better IDE support than the macro based selectMany, so prefer select() for the general case. \nWe often want to give more expressive types to the result of our computations.\nas[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long\nas the types in U and T align.\nWhen the cast is valid the expression compiles:\ncase class UpdatedSurface(city: String, surface: Int)\n// defined class UpdatedSurface\n\nval updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]\n// updated: frameless.TypedDataset[UpdatedSurface] = [city: string, surface: int]\n\nupdated.show(2).run()\n// +-----+-------+\n// | city|surface|\n// +-----+-------+\n// |Paris| 52|\n// |Paris| 102|\n// +-----+-------+\n// only showing top 2 rows\n//\n\nNext we try to cast a (String, String) to an UpdatedSurface (which has types String, Int).\nThe cast is not valid and the expression does not compile:\naptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// :33: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]\n// aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// ^\n\nProjections\nWe often want to work with a subset of the fields in a dataset.\nProjections allows to easily select the fields we are interested\nwhile preserving their initial name and types for extra safety.\nHere is an example using the TypedDataset[Apartment] with an additional column:\nimport frameless.implicits.widen._\n// import frameless.implicits.widen._\n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\ncase class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)\n// defined class ApartmentDetails\n\nval aptWithRatio = aptds.select(aptds('city), aptds('price), aptds('surface), aptds('price) / aptds('surface)).as[ApartmentDetails]\n// aptWithRatio: frameless.TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]\n\nSuppose we only want to work with city and ratio:\ncase class CityInfo(city: String, ratio: Double)\n// defined class CityInfo\n\nval cityRatio = aptWithRatio.project[CityInfo]\n// cityRatio: frameless.TypedDataset[CityInfo] = [city: string, ratio: double]\n\ncityRatio.show(2).run()\n// +-----+------+\n// | city| ratio|\n// +-----+------+\n// |Paris|6000.0|\n// |Paris|4500.0|\n// +-----+------+\n// only showing top 2 rows\n//\n\nSuppose we only want to work with price and ratio:\ncase class PriceInfo(ratio: Double, price: Double)\n// defined class PriceInfo\n\nval priceInfo = aptWithRatio.project[PriceInfo]\n// priceInfo: frameless.TypedDataset[PriceInfo] = [ratio: double, price: double]\n\npriceInfo.show(2).run()\n// +------+--------+\n// | ratio| price|\n// +------+--------+\n// |6000.0|300000.0|\n// |4500.0|450000.0|\n// +------+--------+\n// only showing top 2 rows\n//\n\nWe see that the order of the fields does not matter as long as the\nnames and the corresponding types agree. However, if we make a mistake in\nany of the names and/or their types, then we get a compilation error.\nSay we make a typo in a field name:\ncase class PriceInfo2(ratio: Double, pricEE: Double)\n\naptWithRatio.project[PriceInfo2]\n// :36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?\n// aptWithRatio.project[PriceInfo2]\n// ^\n\nSay we make a mistake in the corresponding type:\ncase class PriceInfo3(ratio: Int, price: Double) // ratio should be Double\n\naptWithRatio.project[PriceInfo3]\n// :36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?\n// aptWithRatio.project[PriceInfo3]\n// ^\n\nUser Defined Functions\nFrameless supports lifting any Scala function (up to five arguments) to the\ncontext of a particular TypedDataset:\n// The function we want to use as UDF\nval priceModifier =\n (name: String, price:Double) => if(name == \"Paris\") price * 2.0 else price\n// priceModifier: (String, Double) => Double = \n\nval udf = aptTypedDs.makeUDF(priceModifier)\n// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = \n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nval adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))\n// adjustedPrice: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\nadjustedPrice.show().run()\n// +-----+--------+\n// | _1| _2|\n// +-----+--------+\n// |Paris|600000.0|\n// |Paris|900000.0|\n// |Paris|500000.0|\n// | Lyon|200000.0|\n// | Lyon|133000.0|\n// | Nice|325000.0|\n// +-----+--------+\n//\n\nGroupBy and Aggregations\nLet's suppose we wanted to retrieve the average apartment price in each city\nval priceByCity = aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('price)))\n// priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\npriceByCity.collect().run()\n// res17: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))\n\nAgain if we try to aggregate a column that can't be aggregated, we get a compilation error\naptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city))) ^\n// :34: error: could not find implicit value for parameter averageable: frameless.CatalystAverageable[String,Out]\n// aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city))) ^\n// ^\n// :34: warning: postfix operator ^ should be enabled\n// by making the implicit value scala.language.postfixOps visible.\n// This can be achieved by adding the import clause 'import scala.language.postfixOps'\n// or by setting the compiler option -language:postfixOps.\n// See the Scaladoc for value scala.language.postfixOps for a discussion\n// why the feature should be explicitly enabled.\n// aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city))) ^\n// ^\n\nNext, we combine select and groupBy to calculate the average price/surface ratio per city:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 1 more field]\n\nval cityPriceRatio = aptds.select(aptds('city), aptds('price) / aptds('surface))\n// cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\ncityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()\n// +-----+------------------+\n// | _1| _2|\n// +-----+------------------+\n// | Nice| 4391.891891891892|\n// |Paris| 6833.333333333333|\n// | Lyon|2682.5970548862115|\n// +-----+------------------+\n//\n\nEntire TypedDataset Aggregation\nWe often want to aggregate the entire TypedDataset and skip the groupBy() clause.\nIn Frameless you can do this using the agg() operator directly on the TypedDataset. \nIn the following example, we compute the average price, the average surface,the minimum surface, and the set of cities for the entire dataset. \ncase class Stats(\n avgPrice: Double, \n avgSurface: Double, \n minSurface: Int, \n allCities: Vector[String])\n// defined class Stats\n\naptds.agg(\n avg(aptds('price)), \n avg(aptds('surface)),\n min(aptds('surface)),\n collectSet(aptds('city))\n).as[Stats].show().run() \n// +-----------------+------------------+----------+-------------------+\n// | avgPrice| avgSurface|minSurface| allCities|\n// +-----------------+------------------+----------+-------------------+\n// |276333.3333333333|62.833333333333336| 25|[Paris, Nice, Lyon]|\n// +-----------------+------------------+----------+-------------------+\n//\n\nJoins\ncase class CityPopulationInfo(name: String, population: Int)\n\nval cityInfo = Seq(\n CityPopulationInfo(\"Paris\", 2229621),\n CityPopulationInfo(\"Lyon\", 500715),\n CityPopulationInfo(\"Nice\", 343629)\n)\n\nval citiInfoTypedDS = TypedDataset.create(cityInfo)\n\nHere is how to join the population information to the apartment's dataset.\nval withCityInfo = aptTypedDs.join(citiInfoTypedDS, aptTypedDs('city), citiInfoTypedDS('name))\n// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct, _2: struct]\n\nwithCityInfo.show().run()\n// +--------------------+---------------+\n// | _1| _2|\n// +--------------------+---------------+\n// | [Paris,50,300000.0]|[Paris,2229621]|\n// |[Paris,100,450000.0]|[Paris,2229621]|\n// | [Paris,25,250000.0]|[Paris,2229621]|\n// | [Lyon,83,200000.0]| [Lyon,500715]|\n// | [Lyon,45,133000.0]| [Lyon,500715]|\n// | [Nice,74,325000.0]| [Nice,343629]|\n// +--------------------+---------------+\n//\n\nThe joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].\nWe can then select which information we want to continue to work with:\ncase class AptPriceCity(city: String, aptPrice: Double, cityPopulation: Int)\n// defined class AptPriceCity\n\nwithCityInfo.select(\n withCityInfo.colMany('_2, 'name), withCityInfo.colMany('_1, 'price), withCityInfo.colMany('_2, 'population)\n).as[AptPriceCity].show().run\n// +-----+--------+--------------+\n// | city|aptPrice|cityPopulation|\n// +-----+--------+--------------+\n// |Paris|300000.0| 2229621|\n// |Paris|450000.0| 2229621|\n// |Paris|250000.0| 2229621|\n// | Lyon|200000.0| 500715|\n// | Lyon|133000.0| 500715|\n// | Nice|325000.0| 343629|\n// +-----+--------+--------------+\n//\n\n"},"TypedDatasetVsSparkDataset.html":{"url":"TypedDatasetVsSparkDataset.html","title":"Comparing TypedDatasets with Spark's Datasets","keywords":"","body":"Comparing TypedDatasets with Spark's Datasets\nGoal:\n This tutorial compares the standard Spark Datasets api with the one provided by\n frameless' TypedDataset. It shows how TypedDatsets allows for an expressive and\n type-safe api with no compromises on performance.\nFor this tutorial we first create a simple dataset and save it on disk as a parquet file.\nParquet is a popular columnar format and well supported by Spark.\nIt's important to note that when operating on parquet datasets, Spark knows that each column is stored\nseparately, so if we only need a subset of the columns Spark will optimize for this and avoid reading\nthe entire dataset. This is a rather simplistic view of how Spark and parquet work together but it\nwill serve us well for the context of this discussion.\nimport spark.implicits._\n// import spark.implicits._\n\n// Our example case class Foo acting here as a schema\ncase class Foo(i: Long, j: String)\n// defined class Foo\n\n// Assuming spark is loaded and SparkSession is bind to spark\nval initialDs = spark.createDataset( Foo(1, \"Q\") :: Foo(10, \"W\") :: Foo(100, \"E\") :: Nil )\n// initialDs: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\n// Assuming you are on Linux or Mac OS\ninitialDs.write.parquet(\"/tmp/foo\")\n\nval ds = spark.read.parquet(\"/tmp/foo\").as[Foo]\n// ds: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\nds.show()\n// +---+---+\n// | i| j|\n// +---+---+\n// |100| E|\n// | 1| Q|\n// | 10| W|\n// +---+---+\n//\n\nThe value ds holds the content of the initialDs read from a parquet file.\nLet's try to only use field i from Foo and see how Spark's Catalyst (the query optimizer)\noptimizes this.\n// Using a standard Spark TypedColumn in select()\nval filteredDs = ds.filter($\"i\" === 10).select($\"i\".as[Long])\n// filteredDs: org.apache.spark.sql.Dataset[Long] = [i: bigint]\n\nfilteredDs.show()\n// +---+\n// | i|\n// +---+\n// | 10|\n// +---+\n//\n\nThe filteredDs is of type Dataset[Long]. Since we only access field i from Foo the type is correct.\nUnfortunately, this syntax requires handholding by explicitly setting the TypedColumn in the select statement\nto return type Long (look at the as[Long] statement). We will discuss this limitation next in more detail.\nNow, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.\nfilteredDs.explain()\n// == Physical Plan ==\n// *Project [i#69L]\n// +- *Filter (isnotnull(i#69L) && (i#69L = 10))\n// +- *BatchedScan parquet [i#69L] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nThe last line is very important (see ReadSchema). The schema read\nfrom the parquet file only required reading column i without needing to access column j.\nThis is great! We have both an optimized query plan and type-safety!\nUnfortunately, this syntax is not bulletproof: it fails at run-time if we try to access\na non existing column x:\nscala> ds.filter($\"i\" === 10).select($\"x\".as[Long])\norg.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];;\n'Project ['x]\n+- Filter (i#69L = cast(10 as bigint))\n +- Relation[i#69L,j#70] parquet\n\n at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:77)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:74)\n at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:308)\n at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:69)\n at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:307)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionUp$1(QueryPlan.scala:269)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:279)\n at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2$1.apply(QueryPlan.scala:283)\n at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n at scala.collection.immutable.List.foreach(List.scala:392)\n at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n at scala.collection.immutable.List.map(List.scala:296)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$2(QueryPlan.scala:283)\n at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$8.apply(QueryPlan.scala:288)\n at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:186)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:288)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:74)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:67)\n at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:126)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:67)\n at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:58)\n at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:49)\n at org.apache.spark.sql.Dataset.(Dataset.scala:161)\n at org.apache.spark.sql.Dataset.(Dataset.scala:167)\n at org.apache.spark.sql.Dataset.select(Dataset.scala:1023)\n ... 450 elided\n\nThere are two things to improve here. First, we would want to avoid the at[Long] casting that we are required\nto type for type-safety. This is clearly an area where we can introduce a bug by casting to an incompatible\ntype. Second, we want a solution where reference to a\nnon existing column name fails at compilation time.\nThe standard Spark Dataset can achieve this using the following syntax.\nds.filter(_.i == 10).map(_.i).show()\n// +-----+\n// |value|\n// +-----+\n// | 10|\n// +-----+\n//\n\nThis looks great! It reminds us the familiar syntax from Scala.\nThe two closures in filter and map are functions that operate on Foo and the\ncompiler will helps us capture all the mistakes we mentioned above.\nscala> ds.filter(_.i == 10).map(_.x).show()\n:20: error: value x is not a member of Foo\n ds.filter(_.i == 10).map(_.x).show()\n ^\n\nUnfortunately, this syntax does not allow Spark to optimize the code.\nds.filter(_.i == 10).map(_.i).explain()\n// == Physical Plan ==\n// *SerializeFromObject [input[0, bigint, true] AS value#105L]\n// +- *MapElements , obj#104: bigint\n// +- *DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#103: $line14.$read$$iw$$iw$$iw$$iw$Foo\n// +- *Filter .apply\n// +- *BatchedScan parquet [i#69L,j#70] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [], ReadSchema: struct\n\nAs we see from the explained Physical Plan, Spark was not able to optimize our query as before.\nReading the parquet file will required loading all the fields of Foo. This might be ok for\nsmall datasets or for datasets with few columns, but will be extremely slow for most practical\napplications.\nIntuitively, Spark currently doesn't have a way to look inside the code we pass in these two\nclosures. It only knows that they both take one argument of type Foo, but it has no way of knowing if\nwe use just one or all of Foo's fields.\nThe TypedDataset in frameless solves this problem. It allows for a simple and type-safe syntax\nwith a fully optimized query plan.\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nval fds = TypedDataset.create(ds)\n// fds: frameless.TypedDataset[Foo] = [i: bigint, j: string]\n\nfds.filter( fds('i) === 10 ).select( fds('i) ).show().run()\n// +---+\n// | _1|\n// +---+\n// | 10|\n// +---+\n//\n\nAnd the optimized Physical Plan:\nfds.filter( fds('i) === 10 ).select( fds('i) ).explain()\n// == Physical Plan ==\n// *Project [i#69L AS _1#176L]\n// +- *Filter (isnotnull(i#69L) && (i#69L = 10))\n// +- *BatchedScan parquet [i#69L] Format: ParquetFormat, InputPaths: file:/tmp/foo, PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nAnd the compiler is our friend.\nscala> fds.filter( fds('i) === 10 ).select( fds('x) )\n:21: error: No column Symbol with shapeless.tag.Tagged[String(\"x\")] of type A in Foo\n fds.filter( fds('i) === 10 ).select( fds('x) )\n ^\n\nDifferences in Encoders\nEncoders in Spark's Datasets are partially type-safe. If you try to create a Dataset using a type that is not \n a Scala Product then you get a compilation error:\nclass Bar(i: Int)\n// defined class Bar\n\nBar is neither a case class nor a Product, so the following correctly gives a compilation error in Spark:\nscala> spark.createDataset(Seq(new Bar(1)))\n:21: error: Unable to find encoder for type stored in a Dataset. Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._ Support for serializing other types will be added in future releases.\n spark.createDataset(Seq(new Bar(1)))\n ^\n\nHowever, the compile type guards implemented in Spark are not sufficient to detect non encodable members. \nFor example, using the following case class leads to a runtime failure:\ncase class MyDate(jday: java.util.Date)\n// defined class MyDate\n\nval myDateDs = spark.createDataset(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// java.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n// - field (class: \"java.util.Date\", name: \"jday\")\n// - root class: \"MyDate\"\n// at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:598)\n// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:592)\n// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:583)\n// at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n// at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n// at scala.collection.immutable.List.foreach(List.scala:392)\n// at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n// at scala.collection.immutable.List.flatMap(List.scala:355)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:583)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:425)\n// at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:61)\n// at org.apache.spark.sql.Encoders$.product(Encoders.scala:274)\n// at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:47)\n// ... 770 elided\n\nIn comparison, a TypedDataset will notify about the encoding problem at compile time: \nTypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// :22: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[MyDate]\n// TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// ^\n\n"},"TypedEncoder.html":{"url":"TypedEncoder.html","title":"Typed Encoders in Frameless","keywords":"","body":"Typed Encoders in Frameless\nSpark uses Reflection to derive it's Encoders, which is why they can fail at run time. For example, because Spark does not supports java.util.Date, the following leads to an error:\nimport org.apache.spark.sql.Dataset\nimport spark.implicits._\n\ncase class DateRange(s: java.util.Date, e: java.util.Date)\n\nscala> val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))\njava.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n- field (class: \"java.util.Date\", name: \"s\")\n- root class: \"DateRange\"\n at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:598)\n at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:592)\n at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$9.apply(ScalaReflection.scala:583)\n at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n at scala.collection.immutable.List.foreach(List.scala:392)\n at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n at scala.collection.immutable.List.flatMap(List.scala:355)\n at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:583)\n at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:425)\n at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:61)\n at org.apache.spark.sql.Encoders$.product(Encoders.scala:274)\n at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:47)\n ... 230 elided\n\nAs shown by the stack trace, this runtime error goes thought ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection based approach is it's inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.\nFrameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the code java.util.Date example won't compile with frameless:\nimport frameless.TypedDataset\n\nval ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// :26: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]\n// val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// ^\n\nType class derivation takes case or recursively constructing (and proving the existence) TypeEncoders for case classes. The following works as expected:\ncase class Bar(d: Double, s: String)\n// defined class Bar\n\ncase class Foo(i: Int, b: Bar)\n// defined class Foo\n\nval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, \"s\"))))\n// ds: frameless.TypedDataset[Foo] = [i: int, b: struct]\n\nds.collect()\n// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@8a0bd3c\n\nBut any non-encodable in the case class hierarchy will be detected at compile time:\ncase class BarDate(d: Double, s: String, t: java.util.Date)\ncase class FooDate(i: Int, b: BarDate)\n\nval ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// :28: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]\n// val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// ^\n\nIt should be noted that once derived, reflection based Encoders and implicitly derived TypeEncoders have identical performances. The derivation mechanism is different, but the objects generated to encode and decode JVM object in the Spark internal representation behave the same at run-time.\n"},"Injection.html":{"url":"Injection.html","title":"Injection: Creating Custom Encoders","keywords":"","body":"Injection: Creating Custom Encoders\nInjection lets us define encoders for types that do not have one by injecting A into an encodable type B.\nThis is the definition of the injection typeclass:\ntrait Injection[A, B] extends Serializable {\n def apply(a: A): B\n def invert(b: B): A\n}\n\nExample\nLet's define a simple case class:\ncase class Person(age: Int, birthday: java.util.Date)\n// defined class Person\n\nval people = Seq(Person(42, new java.util.Date))\n// people: Seq[Person] = List(Person(42,Tue May 23 10:57:10 CEST 2017))\n\nAnd an instance of a TypedDataset:\nval personDS = TypedDataset.create(people)\n// :24: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n// val personDS = TypedDataset.create(people)\n// ^\n\nLooks like we can't, a TypedEncoder instance of Person is not available, or more precisely for java.util.Date.\nBut we can define a injection from java.util.Date to an encodable type, like Long:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = new Injection[java.util.Date, Long] {\n def apply(d: java.util.Date): Long = d.getTime()\n def invert(l: Long): java.util.Date = new java.util.Date(l)\n}\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@6d6cc4bc\n\nWe can be less verbose using the Injection.apply function:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@79ea3da5\n\nNow we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, birthday: bigint]\n\nAnother example\nLet's define a sealed family:\nsealed trait Gender\n// defined trait Gender\n\ncase object Male extends Gender\n// defined object Male\n\ncase object Female extends Gender\n// defined object Female\n\ncase object Other extends Gender\n// defined object Other\n\nAnd a simple case class:\ncase class Person(age: Int, gender: Gender)\n// defined class Person\n\nval people = Seq(Person(42, Male))\n// people: Seq[Person] = List(Person(42,Male))\n\nAgain if we try to create a TypedDataset, we get a compilation error.\nval personDS = TypedDataset.create(people)\n// :32: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n// val personDS = TypedDataset.create(people)\n// ^\n\nLet's define an injection instance for Gender:\nimplicit val genderToInt: Injection[Gender, Int] = Injection(\n {\n case Male => 1\n case Female => 2\n case Other => 3\n },\n {\n case 1 => Male\n case 2 => Female\n case 3 => Other\n })\n// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@70fdc07e\n\nAnd now we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, gender: int]\n\n"},"Job.html":{"url":"Job.html","title":"Job[A]","keywords":"","body":"Job[A]\nAll operations on TypedDataset are lazy. An operation either returns a new\ntransformed TypedDataset or a Job[A], where A is the result of running a\nnon-lazy computation in Spark. Job serves several functions:\n\nMakes all operations on a TypedDataset lazy, which makes them more predictable compared to having\nfew operations being lazy and other being strict\nAllows the programmer to make expensive blocking operations explicit\nAllows for Spark jobs to be lazily sequenced using monadic composition via for-comprehension\nProvides an obvious place where you can annotate/name your Spark jobs to make it easier\nto track different parts of your application in the Spark UI\n\nThe toy example showcases the use of for-comprehension to explicitly sequences Spark Jobs.\nFirst we calculate the size of the TypedDataset and then we collect to the driver\nexactly 20% of its elements:\nval ds = TypedDataset.create(1 to 20)\n// ds: frameless.TypedDataset[Int] = [_1: int]\n\nval countAndTakeJob =\n for {\n count \nThe countAndTakeJob can either be executed using run() (as we show above) or it can\nbe passed along to other parts of the program to be further composed into more complex sequences\nof Spark jobs.\nimport frameless.Job\n// import frameless.Job\n\ndef computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min)\n// computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]\n\nval finalJob = computeMinOfSample(countAndTakeJob)\n// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@2e359e76\n\nNow we can execute this new job by specifying a group-id and a description.\nThis allows the programmer to see this information on the Spark UI and help track, say,\nperformance issues.\nfinalJob.\n withGroupId(\"samplingJob\").\n withDescription(\"Samples 20% of elements and computes the min\").\n run()\n// res2: Int = 1\n\n"},"Cats.html":{"url":"Cats.html","title":"Using Cats with RDDs","keywords":"","body":"Using Cats with RDDs\nData aggregation is one of the most important operations when working with Spark (and data in general).\nFor example, we often have to compute the min, max, avg, etc. from a set of columns grouped by\ndifferent predicates. This section shows how cats simplifies these tasks in Spark by\nleveraging a large collection of Type Classes for ordering and aggregating data.\nAll the examples below assume you have previously imported cats.implicits.\nimport cats.implicits._\n// import cats.implicits._\n\nCats offers ways to sort and aggregate tuples of arbitrary arity.\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nval data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[0] at makeRDD at :21\n\nprintln(data.csum)\n// (10,9,9)\n\nprintln(data.cmax)\n// (8,2,3)\n\nprintln(data.cmin)\n// (1,2,3)\n\nThe following example aggregates all the elements with a common key.\ntype User = String\n// defined type alias User\n\ntype TransactionCount = Int\n// defined type alias TransactionCount\n\nval allData: RDD[(User,TransactionCount)] =\n sc.makeRDD((\"Bob\", 12) :: (\"Joe\", 1) :: (\"Anna\", 100) :: (\"Bob\", 20) :: (\"Joe\", 2) :: Nil)\n// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[1] at makeRDD at :24\n\nval totalPerUser = allData.csumByKey\n// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[2] at reduceByKey at implicits.scala:18\n\ntotalPerUser.collectAsMap\n// res7: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)\n\nThe same example would work for more complex keys.\nval allDataComplexKeu =\n sc.makeRDD( (\"Bob\", Map(\"task1\" -> 10)) ::\n (\"Joe\", Map(\"task1\" -> 1, \"task2\" -> 3)) :: (\"Bob\", Map(\"task1\" -> 10, \"task2\" -> 1)) :: (\"Joe\", Map(\"task3\" -> 4)) :: Nil )\n// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ParallelCollectionRDD[3] at makeRDD at :22\n\nval overalTasksPerUser = allDataComplexKeu.csumByKey\n// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ShuffledRDD[4] at reduceByKey at implicits.scala:18\n\noveralTasksPerUser.collectAsMap\n// res8: scala.collection.Map[String,scala.collection.immutable.Map[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))\n\nJoins\n// Type aliases for meaningful types\ntype TimeSeries = Map[Int,Int]\n// defined type alias TimeSeries\n\ntype UserName = String\n// defined type alias UserName\n\nExample: Using the implicit full-our-join operator\nimport frameless.cats.outer._\n// import frameless.cats.outer._\n\nval day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 2, 1 -> 4)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Sam\", Map(0 -> 1)) :: Nil )\n// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[5] at makeRDD at :26\n\nval day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 10, 1 -> 11)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Joe\", Map(0 -> 1, 1 -> 2)) :: Nil )\n// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[6] at makeRDD at :26\n\nval daysCombined = day1 |+| day2\n// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[10] at mapValues at implicits.scala:43\n\ndaysCombined.collect()\n// res10: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))\n\nNote how the user's timeseries from different days have been aggregated together.\nThe |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join\non the key and combine values using the default Semigroup for the value type.\nIn cats:\nMap(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)\n// res11: Map[Int,Int] = Map(1 -> 6, 2 -> 2)\n\n"},"TypedDataFrame.html":{"url":"TypedDataFrame.html","title":"Proof of Concept: TypedDataFrame","keywords":"","body":"Proof of Concept: TypedDataFrame\nTypedDataFrame is the API developed in the early stages of frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future developments of frameless. However, the design is interesting enough for being documented.\nTo safely manipulate DataFrames we use a technique called shadow type, which consists in storing additional information about a value in a \"dummy\" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.\nDiving in\nIn TypedDataFrame, we use a single Schema to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:\nimport org.apache.spark.sql.DataFrame\nimport shapeless.HList\n\nclass TDataFrame[Schema Boolean): TDataFrame[Schema] = ???\n\n def select[C \nAs you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.\nType-level column referencing\nFor Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching column referencing at compile type. When everything goes well, frameless select is very similar to vanilla select, except that it keeps track of the selected column types:\nimport frameless.TypedDataFrame\n\ncase class Foo(s: String, d: Double, i: Int)\n\ndef selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n tf.select('i, 's)\n\nHowever, in case of typo, it gets coughs right away:\ndef selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n tf.select('j, 's)\n\nType-level joins\nJoins can available with two different syntaxes, the first lets you reference different columns on each TypedDataFrame, and ensures that their all exists and have compatible types:\ncase class Bar(i: Int, j: String, b: Boolean)\n\ndef join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =\n tf1.innerJoin(tf2).on('s).and('j)\n\nThe second syntax bring some convenience when the joining columns have identical names in both tables:\ndef join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n : TypedDataFrame[(String, Double, Int, String, Boolean)] =\n tf1.innerJoin(tf2).using('i)\n\nFurther example are available in the TypedDataFrame join tests.\nComplete example\nWe now consider a complete example to see how the type system can frameless can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city map and neighborhood:\ntype Neighborhood = String\ntype Address = String\n\ncase class PhoneBookEntry(\n address: Address,\n residents: String,\n phoneNumber: Double\n)\n\ncase class CityMapEntry(\n address: Address,\n neighborhood: Neighborhood\n)\n\nOur goal will be to compute the neighborhood with unique names, approximating \"unique\" with names containing less common\nletters in the alphabet: 'x', 'q', and 'z'. We are going to need a natural language processing library at some point, so\nlet's use the following for the example:\nobject NLPLib {\n def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))\n}\n\nSuppose we manage to obtain a TypedDataFrame[PhoneBookEntry] and a TypedDataFrame[CityMapEntry] public data, here is what our Spark job could look like with frameless:\nimport org.apache.spark.sql.SQLContext\n\n// These case classes are used to hold intermediate results\ncase class Family(residents: String, neighborhood: Neighborhood)\ncase class Person(name: String, neighborhood: Neighborhood)\ncase class NeighborhoodCount(neighborhood: Neighborhood, count: Long)\n\ndef bestNeighborhood\n (phoneBookTF: TypedDataFrame[PhoneBookEntry], cityMapTF: TypedDataFrame[CityMapEntry])\n (implicit c: SQLContext): String = {\n (((((((((\n phoneBookTF\n .innerJoin(cityMapTF).using('address) :TypedDataFrame[(Address, String, Double, String)])\n .select('_2, '_4) :TypedDataFrame[(String, String)])\n .as[Family]() :TypedDataFrame[Family])\n .flatMap { f =>\n f.residents.split(' ').map(r => Person(r, f.neighborhood))\n } :TypedDataFrame[Person])\n .filter { p =>\n NLPLib.uniqueName(p.name)\n } :TypedDataFrame[Person])\n .groupBy('neighborhood).count() :TypedDataFrame[(String, Long)])\n .as[NeighborhoodCount]() :TypedDataFrame[NeighborhoodCount])\n .sortDesc('count) :TypedDataFrame[NeighborhoodCount])\n .select('neighborhood) :TypedDataFrame[Tuple1[String]])\n .head._1\n}\n\nIf you compare this version from Spark vanilla where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.\nLimitations\nThe main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.\nIn the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.\n"}}} \ No newline at end of file +{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["\"0.3.0\"","\"frameless","\"org.typelevel\"","%","%%","(e.g.","(includ","(peopl","(support","(thumb",")","++=","+1,","+=","0.13.13:","0.9.x)","2.0","2.0,","2.0.x)","2.11.x.","=",">=","add","adelbertc","against","apach","api:","are:","associ","avail","base","benefit","bootstrap","break","bring","build.sbt","built","cast","cat","cats\"","chang","channel","code","column","compar","compil","concept","concept:","conduct","consist","consol","contribut","contributor","creat","current","custom","customizable,","dataset","dataset\"","depend","develop","document","easi","encod","enhanc","environ","express","featur","few","file","file.","follow","frameless","framelessvers","framelessversion,","friendli","function","g8","get","giter8","github,","gitter)","ground,","http://opensource.org/licenses/apach","imario","imarios/frameless.g8","injection:","insid","instal","introduct","jeremyrsmith","job[a]","kanterov","learning.","librari","librarydepend","licens","list(","load","made","maintain","merg","ml","modules:","more","needed:","new","next","non","note","olivierblanvillain","on","overview","possibl","project","project:","proof","provid","pull","quick","rdd","referenc","requests)","requests.","requir","resolv","resolver.sonatyperepo(\"releases\")","safe","same","sbt","scala","shell","sign","signatur","similar)","simply:","spark","spark'","spark).","spark.","standard","start","still","strongli","support","type","typeddatafram","typeddataset","typeddataset:","typelevel","types.","typesaf","under","up","up,","us","val","veri","versions.","want","way","well","why?","work"],"FeatureOverview.html":["\"false\")","\"paris\")","'`citi`'","'name),","'population)","'price),","'project","(a)","(automated)","(b)","(enjoy","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(in","(lyon,166500.0))","(manual)","(name:","(paris,333333.3333333333),","(string,","(u:","(up","(which","(with",")",").as[aptpricecity].show().run",").as[stats].show().run()","*","+","...","/","//","1),","10,","100,","10000.0,","102|","133000.0,","133000.0|","2","2),","2).as[updatedsurface]","2).show().run()","2.0","200000.0,","200000.0|","2229621),","2229621|","2409.6385542168673,","25,","250000.0,","250000.0|","250|","25|[paris,","27|","2955.5555555555557,","3","3)","3),","300000.0,","300000.0|","325000.0,","325000.0|","343629)","343629|","4","434","4391.891891891892)","4391.891891891892|","45,","4500.0,","450000.0,","450000.0|","450|","47|","50,","500715),","500715|","500|","52|","6833.333333333333|","74,","740|","76|","83,","830|","85|",":27:",":28:",":31:",":33:",":34:",":36:","=","==","=>","['citi]","[1...10]).","[_1:","[city#53,","[city,","[city:","[lyon,500715]|","[nice,343629]|","[out](other:","[ratio:","^","_1|","_2:","_2|","abov","actual","addit","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","agg()","agg(avg(aptds('price))).","aggreg","aggregated,","agree.","align.","allcities:","allcities|","allow","allowed,","allowed.","alternatives:","and/or","anoth","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartmentdetail","apartmentdetails(city:","apartmentdetails?","api","appear","appli","aptd","aptds('price)","aptds('price)))","aptds('price),","aptds('surface))","aptds('surface)).as[apartmentdetails]","aptds('surface),","aptds.","aptds.agg(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)).as[updatedsurface]","apttypedds('city),","apttypedds('city).cast[double]","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.join(citiinfotypedds,","apttypedds.makeudf(pricemodifier)","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds2","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","arguments)","as:","as[bedroomstats]","as[t]","avail","available.","averag","avg(aptds('price)),","avg(aptds('surface)),","avgprice:","avgpricebeds1:","avgpricebeds2:","avgpricebeds3:","avgpricebeds4:","avgprice|","avgsurface:","avgsurface|minsurface|","base","bedroom","bedrooms#56]","bedrooms.","bedrooms:","bedrooms];;","bedroomstat","bedroomstats(","bedroomstats(lyon,some(133000.0),some(200000.0),none,none)","bedroomstats(nice,none,none,some(325000.0),none)","bedroomstats(paris,some(250000.0),some(300000.0),some(450000.0),none)","bedroomstats.collect().run().foreach(println)","bedroomstats.show().run()","bedroomstats:","better","between","boolean","boolean)].","c:","calcul","can't","care","case","case.","cast","cast,","catalystcast.","catalystcast[string,","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name))","city:","cityinfo","cityinfo(city:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|avgpricebeds1|avgpricebeds2|avgpricebeds3|avgpricebeds4|","city|surface|","class","class:","clause.","code","collect","collectset(aptds('city))","column","column.","column:","columns:","combin","compar","compil","compile.","compile:","compiles:","complet","comput","computations.","conf","context","continu","correspond","creat","data","dataset","dataset.","dataset:","defin","detail","directli","divid","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","e:","each","easili","elid","encod","entir","error","error.","error:","evid","exampl","example,","example.","exist","explan","explicitli","express","extra","featur","few","field","fields]","find","five","follow","form","frameless","frameless.catalystcast[string,double]","frameless.catalystdivisible[double,out],","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.functions.aggregate._","frameless.implicits.widen._","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[apartment,double])(implicit","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[bedroomstats]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","frameless.typedencoder[out])frameless.typedcolumn[apartment,out]","function","further","gener","get","give","given","group","groupbi","groupby()","groupby(aptds('city)).","here","here.","here:","however,","id","if(nam","implicit","implicitli","import","inform","initi","input","instanc","instances:","instanti","int","int)","int).","int,","int.","int]","interest","introduc","job","join","lazi","lazy.","let'","lift","localrel","long","look","lyon]|","lyon|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","macro","make","materialize.","math","matter","member","method","method.","min(aptds('surface)),","minimum","minsurface:","miss","missing,","misspel","mistak","more","n","n:","name","name:","need","new","next","next,","nice,","nice|","nice|325000.0|","not,","note","now","null|","number","on","on(1,2,3,4).","oper","operations:","option","option.","option[double])","option[double],","order","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:88)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$6.apply(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1$1.apply(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$transformexpressionsup$1.apply(queryplan.scala:268)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:289)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:268)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:70)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:289)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:127)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:187)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:288)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:66)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2872)","org.apache.spark.sql.dataset.select(dataset.scala:1153)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:52)","org.apache.spark.sql.sparksess","org.apache.spark.{sparkconf,","overload","overview","paramet","particular","per","perform","perhap","pivot","pivot(aptds('bedrooms)).","pivot,","popul","population:","potenti","prefer","preserv","price","price#55,","price,","price/surfac","price:","price:double)","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.collect.run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","proce","project","prove","rais","ratio","ratio:","ratio|","readi","referenc","repl\").set(\"spark.ui.enabled\",","requir","res17:","res6:","res7:","resolv","result","retriev","right?","row","run","run()","safe","safe,","safe.","safety,","safety.","same","scala","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","secondari","see","seem","select","select()","selectmany()","selectmany,","seq(","seq[(string,","seq[double]","set","shapeless.tag.tagged[string(\"citi\")]","shorter","show","show()","simpl","skip","spark","spark.createdataset(apartments)","spark.implicits._","spark.sparkcontext.setloglevel(\"warn\")","spark.sqlcontext","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","sqlcontext","stack","standard","start","stat","stats(","string","string)","string),updatedsurface]","string,","string.","string]","struct,","struct]","subset","suggests,","support","suppos","surfac","surface#54,","surface,","surface,th","surface:","symbol","syntax:","t","tell","ten","three","time","time,","top","trace):","tri","tutori","two","type","type:","typedcolumn","typeddataset","typeddataset.","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","types,","typesaf","typesafeti","typo","u","udf","udf(aptds('city),","udf:","unit:","unlik","unsaf","up","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","val","valid","valu","vector[string])","want","way","wherea","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","work","worked,","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","|","|1000|102|","|276333.3333333333|62.833333333333336|","|4500.0|450000.0|","|6000.0|300000.0|","|[lyon,45,133000.0,1]|","|[lyon,83,200000.0,2]|","|[nice,74,325000.0,3]|","|[paris,100,450000...|[paris,2229621]|","|[paris,25,250000....|[paris,2229621]|","|[paris,50,300000....|[paris,2229621]|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|"],"TypedDatasetVsSparkDataset.html":["\"e\")","\"java.util.date\",","\"jday\")","\"mydate\"","\"q\")","\"w\")","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","&&","'`x`'","'project","(case","(class:","(i#1131l","(int,","(isnotnull(i#1131l)","(look","(see","(the",")",").explain()",").select(",").show().run()","*deserializetoobject","*filescan","*filter","*mapel","*project","*serializefromobject","+",",","...",".appli","//","10","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10|","1|","454","778",":20:",":24:",":25:","::","=","==","===","['x]","[],","[i#1131l","[i#1131l,j#1132]","[i#1131l]","[i,","[i:","[input[0,","[isnotnull(i),","^","_1#1236l]","_1|","above.","access","achiev","act","ad","allow","api","applications.","area","argument","as[long]","assum","at[long]","avoid","bar","bar(1)))","bar(i:","batched:","before.","bigint","bigint))","bigint,","bigint]","bind","both","bug","bulletproof:","captur","case","cast","cast(10","catalyst","class","class:","classes)","clearli","closur","closures.","code","code.","column","columnar","columns,","columns:","compar","comparison,","compil","compromis","content","context","correct.","correctli","creat","current","dataset","dataset.","dataset[long].","datasets,","defin","detail.","detect","differ","discuss","discussion.","disk","doesn't","ds","ds.filter($\"i\"","ds.filter(_.i","ds.show()","ds:","each","elid","encod","encoder:","entir","equalto(i,10)],","error","error:","etc)","exampl","example,","exist","explain","explicitli","express","extrem","e|","fail","failure:","false]","familiar","fd","fds('i)","fds('x)","fds.filter(","fds:","few","field","fields.","file","file.","filter","filteredd","filteredds.explain()","filteredds.show()","filteredds:","find","first","first,","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo,","foo.","format","format:","found","frameless","frameless'","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[mydate]","friend.","fulli","function","futur","generated.","give","given","goal:","great!","guard","handhold","help","here","here.","hold","however,","implement","implicit","import","improv","incompat","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inmemoryfileindex[file:/tmp/foo],","input","insid","int)","introduc","intuitively,","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date(system.currenttimemillis))))","java.util.date)","j|","know","last","lead","let'","limit","line","linux","load","location:","long","long,","look","mac","map","member","members.","mention","mistak","more","mydat","mydate(jday:","name","name:","need","newinstance(class","next","nil","non","note","notifi","now,","obj#1163:","obj#1164:","ok","on","oper","optim","optimizer)","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:88)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:71)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$6.apply(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1$1.apply(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$transformexpressionsup$1.apply(queryplan.scala:268)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:289)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:268)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$10.apply(scalareflection.scala:607)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$10.apply(scalareflection.scala:619)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:607)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:625)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:438)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:70)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:289)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:127)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:187)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:288)","org.apache.spark.sql.dataset.(dataset.scala:164)","org.apache.spark.sql.dataset.(dataset.scala:170)","org.apache.spark.sql.dataset.select(dataset.scala:1213)","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:275)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:52)","org.apache.spark.sql.lowprioritysqlimplicits$class.newproductencoder(sqlimplicits.scala:233)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:33)","os","paramet","parquet","parquet,","partial","partitionfilters:","pass","performance.","physic","plan","plan,","plan.","plan:","popular","practic","primit","problem","problem.","product","product,","provid","pushedfilters:","queri","quick","q|","read","readschema).","readschema:","refer","relation[i#1131l,j#1132]","releases.","remind","requir","resolv","return","root","run","runtim","safe","safe.","safety!","safety.","save","scala","scala.","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala>","schema","second,","see","select","select()","separately,","serial","serv","set","shapeless.tag.tagged[string(\"x\")]","show","simpl","simplist","slow","small","solut","solv","spark","spark'","spark.","spark.createdataset(","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark:","sparksess","standard","statement","statement).","store","string)","string,","string]","struct","subset","suffici","support","symbol","syntax","syntax.","take","thing","this.","time","time.","time:","togeth","tri","true,","tutori","two","type","type.","typedcolumn","typeddataset","typeddataset.","typeddataset.create(ds)","typeddataset.create(seq(mydate(new","typeddatset","unabl","unfortunately,","us","val","valu","value#1165l]","veri","view","want","way","well","without","work","w|","x","x:","|","|100|","|value|"],"TypedEncoder.html":["\"daterange\"","\"java.util.date\",","\"s\")","\"s\"))))","\"s\",","(a","(and","(class:","...","//","2.0)","242",":29:",":31:","=","[i:","^","annoy","approach","around","b:","bar","bar(1.1,","bar(d:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","behav","besid","call","care","case","class","class:","classes.","code","compil","construct","coupl","current","custom","data","data.","dataset","dataset?.","dataset[daterange]","daterange(s:","decod","defin","deriv","derived,","detect","different,","double,","ds.collect()","ds:","e:","elid","encod","encoder.","encoder:","encoders,","ensur","error","error:","exampl","example,","exist","expected:","extend","fail","field","find","follow","foo","foo(i:","foodate(i:","found","frameless","frameless.job$$anon$4@208e2282","frameless.job[seq[foo]]","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless:","gener","goe","hierarchi","ident","implicit","implicitli","import","inabl","int,","intern","introduc","issues.","it'","java.lang.unsupportedoperationexception:","java.util.d","java.util.date)","java.util.date)))","java.util.date))))","java.util.date,","jvm","lead","limit","manipul","mechan","method","more","name:","new","non","note","object","of)","onc","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:71)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$10.apply(scalareflection.scala:607)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$10.apply(scalareflection.scala:619)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:607)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:625)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:438)","org.apache.spark.sql.dataset","org.apache.spark.sql.encoders$.product(encoders.scala:275)","org.apache.spark.sql.lowprioritysqlimplicits$class.newproductencoder(sqlimplicits.scala:233)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:33)","overflow","paramet","pass","performances.","prove","question","recurs","reflect","represent","res2:","resolut","root","run","runtim","s:","same","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala>","scalareflect","schema.","see","shapeless","shown","situat","solv","spark","spark.implicits._","spark:","sqlcontext.createdataset(seq(daterange(new","stack","standard","store","string)","string,","struct]","summari","support","t:","take","thought","time,","time.","time:","trace,","tri","type","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeencod","types.","us","val","valu","vanilla","won't","work"],"Injection.html":["$anon$1@2b4ee43","//","09:21:38","1","18","2","2017))","3",":24:",":32:","=","=>","[age:","^","a):","again","anoth","apply(a:","apply(d:","available,","b","b):","b.","b]","bigint]","birthday:","can't,","case","class","class:","compil","creat","custom","d.gettime()","datetolonginject","datetolonginjection:","def","defin","definit","encod","encoder:","error.","error:","exampl","extend","family:","femal","find","frameless._","frameless.injection$$anon$1@5a548922","frameless.injection$$anon$1@62c73008","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.typeddataset[person]","frameless.typedencoder[person]","function:","gender","gender)","gender:","gendertoint:","implicit","import","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","instanc","int,","int]","invert(b:","invert(l:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date)","java.util.date))","java.util.date).gettime(),","java.util.date):","java.util.date.","less","let","let'","list(person(42,male))","list(person(42,w","long","long)))","long):","long:","long]","look","male","male))","more","new","now","object","oct","on","paramet","pdt","peopl","people:","person","person(age:","persond","personds:","precis","seal","seq(person(42,","seq[person]","serializ","simpl","trait","tri","type","type,","typeclass:","typeddataset,","typeddataset.create(people)","typeddataset:","typedencod","us","val","valu","verbos","{","}","})","},"],"Job.html":["(a","(sample:","//","1","20%","20)","=","=>","[_1:","abil","above)","above,","allow","along","annotate/nam","applic","be","block","calcul","call","captur","cat","cats.effect.sync","collect","compar","complex","compos","composit","comprehens","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","constructor","count","countandtakejob","data","def","default","description.","differ","driver","ds","ds:","easier","effect","effects.","element","elements:","exactli","exampl","example,","execut","expens","explicit","explicitli","f[_]","f[a]","f[a],","few","finaljob","finaljob.","finaljob:","first","frameless.","frameless.job","frameless.job$$anon$2@6ef768bf","frameless.job[int]","frameless.job[seq[int]])frameless.job[int]","frameless.syntax._","frameless.typeddataset[int]","functions:","further","group","have","help","id","implement","implicitli","import","inform","instanc","instance.","int","int]","issues.","job","job[a]","job[int]","job[seq[int]]):","jobs.","lazi","lazili","lazy,","lazy.","make","mention","min\").","module,","monad","more","new","non","now","obviou","open","oper","order","part","pass","perform","place","predict","program","programm","provid","repres","requir","res2:","result","return","run","run()","sample.map(_.min)","say,","see","sequenc","serv","sever","show","showcas","size","spark","spark.","sparkdelay","sparkdelay[f[_]]","sparksession.","specifi","strict","such","support","suspend","suspens","thunk","toy","track","track,","transform","type","typeclass","typeclass,","typeddataset","typeddataset.create(1","ui","us","user","val","value,","via","withdescription(\"sampl","withgroupid(\"samplingjob\").","{"],"Cats.html":["\"another\")))","\"string\"),","\"task2\"","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(1,","(1,2,3)","(10,9,9)","(2,","(8,","(8,2,3)","(and","(chris,map(0","(john,map(0","(sam,map(0","(semigroup)","(seq[(int,","(wrappedarray((1,string)),2)",")","//","1","1)","1))","1)),","1),","1,","10))","10,","100)","11))","12)","12,","15)))","2","2)","2))","2)),","2,","20)","20,","3)","3))","3,","32,","4))","4)),","4,","5,","6,",":45",":46",":48",":50","::","=",">","[_1:","_2:","abil","above.","abstract","action","action[(seq[(int,","action[t]","aggreg","algebra","alia","alias","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","anna","api","arbitrari","arity.","array((joe,map(0","array[(username,","assum","avg,","be","below","block","capabl","captur","cat","cats.data.readert","cats.effect.implicits._","cats.effect.io","cats.effect.sync[f].","cats.implicit","cats.implicits._","cats.mtl.implicits._","cats:","class","collect","column","combin","common","complex","comput","constructor","conveni","data","data.","data:","dataset","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","default","defin","delay","descript","description:","differ","effect","effect:","effects.","element","enhanc","enrich","etc.","exampl","example,","example:","execut","exist","f[_]","f[_],","fanci","first","follow","frameless","frameless.cats.implicits.","frameless.cats.implicits._","frameless.cats.implicits._.","frameless.cats.outer._","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[(int,","frameless:","full","general).","given","group","implicit","implicits.scala:18","implicits.scala:43","import","instanc","int","int)]","int,","integr","io","job,","joe","join","kernel","key","key.","keys.","larg","layer","lazy.","leverag","library:","local","long)","long)]","machineri","main","makerdd","map(\"task1\"","map(\"task3\"","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[24]","mapvalu","max,","meaning","method","min,","modifi","module,","monad","more","mtl","namely,","need","nil","nil)","normal","note","noth","now,","offer","on","oper","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","outer","over","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","pair","parallelcollectionrdd[14]","parallelcollectionrdd[15]","parallelcollectionrdd[17]","parallelcollectionrdd[19]","parallelcollectionrdd[20]","part","plain","pre","predicates.","previous","println(data.cmax)","println(data.cmin)","println(data.csum)","program,","properli","provid","r","rdd","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","readert","readert[io,","reducebykey","repres","request","res10:","res11:","res13:","res14:","res5:","res6:","result","result.run(spark).unsaferunsync()","result:","resultwithdescription.run(spark).unsaferunsync()","resultwithdescription:","run","run:","same","sampl","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala.collection.immutable.map[string,int])]","scala.collection.map[string,scala.collection.immutable.map[string,int]]","scala.collection.map[user,transactioncount]","section","semigroup","set","show","shuffledrdd[16]","shuffledrdd[18]","simplifi","sort","spark","sparkdelay","sparkdelay[f].","sparksess","sparksession,","sparksession.","stack","stack.","stack:","string","string)]","string)],","string]","suppli","suspend","suspended.","suspens","syntax","t]","task","task2","task3","thread","timeseri","timeseries)]","togeth","together.","totalperus","totalperuser.collectasmap","totalperuser:","transactioncount","transactioncount)]","tupl","two","type","type.","typeclass","typedd","typeddataset","typeddataset.create(seq((1,","typedds:","us","user","user'","usernam","util","val","valu","variabl","way","work","work,","wrap","yet.","{","|+|"],"TypedML.html":["//","1,","1.0","2))","2,","2.0","3)","=",">","[1.0,2.0,3.0]","[_1:","_2:","algebra","api","array(1,","begin","companion","currently,","data","defin","deriv","encod","eventu","frameless","frameless.ml._","frameless.typeddataset","frameless.typeddataset[(string,","goal","hood,","implicit","import","instanc","linear","matrices.dense(2,","matrix","matrix))","matrix:","matrix]","matrixd","matrixds:","ml","ml'","modul","more","object.","org.apache.spark.ml.linalg._","org.apache.spark.ml.linalg.matrix","org.apache.spark.ml.linalg.matrix)]","org.apache.spark.ml.linalg.matrix:","org.apache.spark.ml.linalg.matrixudt.","org.apache.spark.ml.linalg.vector","org.apache.spark.ml.linalg.vector)]","org.apache.spark.ml.linalg.vectorudt","org.apache.spark.sql.types.userdefinedtype[a]","possibl","provid","spark","spark.","string,","strongli","support","thank","type","typeddataset","typeddataset.create(seq(\"label\"","typedencod","typedencoder[a]","types.","under","us","val","vector","vector))","vector:","vector]","vectord","vectords:","vectors.dense(1,","veri"],"TypedDataFrame.html":["\"dummy\"","\"unique\"","').map(r","'_4)","'q',","'s)","'x',","'z'))","'z'.","(((((((((","(implicit","(phonebooktf:",")",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","//","1.6","1.6+,","1.6,","11","2.10,","2.11","2.11,","22.",":",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","=>","???","addit","address","address,","address:","alphabet:","alternatively,","amount","api","approach","approxim","ariti","avail","away:","b:","bar(i:","be","bestneighborhood","boolean","boolean)","boolean):","boolean)]","boolean,","both","bring","c:","call","case","catch","caus","citi","citymapentry(","citymaptf:","class","column","columns.","come","common","commonli","compar","compat","compil","complet","comput","concept:","consid","consist","contain","conveni","correct","cough","count:","d:","data,","datafram","dataframe,","dataframes,","dataset","def","defin","definit","deprec","design","develop","differ","directli","dive","documented.","domain","done","doubl","double,","due","each","earli","element","enough","ensur","essenti","everyth","exampl","example:","except","execut","exist","expect","f","f.neighborhood))","f.residents.split('","fact","family(residents:","field","filter(conditionexpr:","first","flat","focu","follow","foo(s:","frameless","frameless.","frameless.typeddatafram","frameless:","function","further","futur","get","go","goal","goe","handl","have","here","hold","however,","i:","ident","import","improv","inform","instead","int)","int,","interest","intermedi","introduc","introduct","j:","job","jobs.","join","join1(tf1:","join2(tf1:","joins,","keep","languag","less","let","let'","letter","level","leverag","librari","like,","limit","limitations.","line","long)","long)])","look","main","manag","manipul","manner.","map","mirror","mistak","model","moder","more","much","name","name.exists(set('x',","names,","natur","need","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","nlplib","nlplib.uniquename(p.name)","now","number,","object","obtain","ontypeddataframe.","onward.","org.apache.spark.sql.datafram","org.apache.spark.sql.sqlcontext","p","packag","pair","person(name:","person(r,","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","point,","possibl","process","product.","proof","provid","public","readability.","readabl","reasons,","refer","referenc","represent","residents:","result","rethought","return","right","sadly,","safe","safety.","scala","schema","schema.","second","see","see,","seem","select","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","shadow","shapeless.hlist","signatures:","similar","simplifi","singl","spark","spark'","spark,","sqlcontext):","stage","still","store","string","string):","string)]","string)])","string,","suppos","syntax","syntaxes,","system","systems,","tabl","table,","tables:","target","tdataframe[schema","tdataframe[schema]","techniqu","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","time.","track","troubl","tuple23","two","type","type,","type.","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry]","typeddataframe[citymapentry])","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","types:","typo,","uniqu","uniquename(name:","us","user","valu","vanilla","variou","veri","version","way","well,","won't","work","zero.","{","}"]},"length":9},"tokenStore":{"root":{"0":{"9":{"docs":{},":":{"2":{"1":{"docs":{},":":{"3":{"8":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{},".":{"1":{"3":{"docs":{},".":{"1":{"3":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"docs":{}},"docs":{}}},"docs":{}},"9":{"docs":{},".":{"docs":{},"x":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}},"docs":{}}},"1":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}},"docs":{}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"i":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"8":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0111731843575419}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008379888268156424},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},".":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"6":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"+":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"docs":{}}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"1":{"7":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"docs":{}},"docs":{},"%":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"4":{"0":{"9":{"docs":{},".":{"6":{"3":{"8":{"5":{"5":{"4":{"2":{"1":{"6":{"8":{"6":{"7":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"2":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"9":{"5":{"5":{"docs":{},".":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006905210295040804},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},".":{"docs":{},"x":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"1":{"0":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{},"x":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"docs":{}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"4":{"3":{"6":{"2":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"4":{"3":{"4":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"9":{"1":{"docs":{},".":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"4":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"6":{"8":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"7":{"4":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"7":{"8":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"docs":{}},"docs":{}},"8":{"3":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{},"\"":{"0":{"docs":{},".":{"3":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"docs":{}}},"docs":{}}},"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},"q":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"w":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"y":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"2":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"docs":{}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"%":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}},"%":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}}},"(":{"1":{"0":{"docs":{},",":{"9":{"docs":{},",":{"9":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}}},"docs":{}}},"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"2":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"8":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"y":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}},"t":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"#":{"1":{"1":{"3":{"1":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"1":{"1":{"3":{"1":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}},"e":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},"q":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"b":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"1":{"6":{"6":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"u":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"docs":{}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{}}}}}}}}}}},"\"":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}}}}}}},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687}}}}},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{}}}}}}}}}},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}},"+":{"1":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0696798493408663},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.04190260475651189}},"+":{"docs":{},"=":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"=":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"=":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.03327055869428751},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.013590033975084938},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.024615384615384615},"Injection.html":{"ref":"Injection.html","tf":0.06329113924050633},"Job.html":{"ref":"Job.html","tf":0.029411764705882353},"Cats.html":{"ref":"Cats.html","tf":0.04329608938547486},"TypedML.html":{"ref":"TypedML.html","tf":0.06015037593984962},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.016605166051660517}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.011325028312570781}},"=":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006795016987542469}}}},">":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}},">":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.055865921787709494},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}},"=":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"a":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"e":{"docs":{},"l":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"d":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003138731952291274}},"s":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"3":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"docs":{},"(":{"docs":{},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"[":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529}}}}}},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"4":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}},"b":{"docs":{},"o":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"i":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"g":{"docs":{},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"n":{"docs":{},"o":{"docs":{},"y":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"t":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"b":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"docs":{}}},"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"s":{"docs":{},"#":{"5":{"6":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006905210295040804},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"(":{"1":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"docs":{}},"docs":{}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007532956685499058},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0056625141562853904},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.021538461538461538},"Injection.html":{"ref":"Injection.html","tf":0.04113924050632911},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01845018450184502}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.017543859649122806},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":3.350093109869646}},"s":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},".":{"docs":{},"e":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"[":{"docs":{},"f":{"docs":{},"]":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}},"o":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}},"m":{"docs":{},"t":{"docs":{},"l":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"r":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"u":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005021971123666039},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.007927519818799546},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012915129151291513}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.502265005662514},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003138731952291274},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.007927519818799546},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012307692307692308},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"x":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}}}}}},"o":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351783517835174}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"o":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"o":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Injection.html":{"ref":"Injection.html","tf":2.5126582278481013}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":2.5031645569620253}},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003138731952291274},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"1":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"3":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"4":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.011299435028248588},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010192525481313703},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.033846153846153845},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.02214022140221402}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.021929824561403508},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.509060022650057},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"\"":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"?":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012915129151291513}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}},"y":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"f":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014760147601476014}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005649717514124294},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.03481012658227848},"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018461538461538463},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005021971123666039},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"e":{"docs":{},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}},"_":{"docs":{},".":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.021538461538461538},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"u":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.013157894736842105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006795016987542469},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3548717948717948},"Injection.html":{"ref":"Injection.html","tf":2.5126582278481013},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"s":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"t":{"docs":{},"i":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"i":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"s":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0056625141562853904},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"u":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"i":{"docs":{},",":{"1":{"0":{"docs":{},")":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}},"docs":{}},"docs":{}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.008379888268156424}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.333961079723791}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005649717514124294}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}},"a":{"docs":{},"l":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.007927519818799546},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},"c":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.039473684210526314},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3425641025641024},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}}}}}}}}}}}}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"5":{"docs":{},"a":{"5":{"4":{"8":{"9":{"2":{"2":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"6":{"2":{"docs":{},"c":{"7":{"3":{"0":{"0":{"8":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"2":{"docs":{},"@":{"6":{"docs":{},"e":{"docs":{},"f":{"7":{"6":{"8":{"docs":{},"b":{"docs":{},"f":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}},"4":{"docs":{},"@":{"2":{"0":{"8":{"docs":{},"e":{"2":{"2":{"8":{"2":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},"_":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}}},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}}}}}}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"s":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"l":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006795016987542469}}}},"x":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"[":{"docs":{},"_":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"a":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"l":{"docs":{},")":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015822784810126583}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}}},"t":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"8":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},"docs":{}}},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"b":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}},"o":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"a":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"l":{"docs":{},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"o":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"v":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"s":{"docs":{},"/":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}},"docs":{}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012307692307692308},"Injection.html":{"ref":"Injection.html","tf":0.015822784810126583},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"docs":{}},"4":{"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{}},"docs":{}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007532956685499058},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010192525481313703},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.015384615384615385},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.03212290502793296},"TypedML.html":{"ref":"TypedML.html","tf":0.045112781954887216},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015822784810126583}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"Injection.html":{"ref":"Injection.html","tf":2.5031645569620253}}},"(":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},"n":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005021971123666039},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"t":{"docs":{"./":{"ref":"./","tf":10},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"g":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"[":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"l":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"f":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"t":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"o":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"j":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"y":{"docs":{},"r":{"docs":{},"s":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"Job.html":{"ref":"Job.html","tf":10.004201680672269}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"i":{"docs":{},"n":{"1":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}}}}},"2":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01107011070110701}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"l":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.015384615384615385}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"v":{"docs":{},"m":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"e":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"s":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}}}}},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.017543859649122806}}}}}},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}},"w":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"docs":{}},"docs":{}}}}}}}}}}},"f":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"a":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}},"u":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"o":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"a":{"docs":{},"z":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"y":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"r":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"8":{"2":{"docs":{},".":{"5":{"9":{"7":{"0":{"5":{"4":{"8":{"8":{"6":{"2":{"1":{"1":{"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"m":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"r":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"Job.html":{"ref":"Job.html","tf":0.01680672268907563}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"2":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"docs":{}}}}}}}}}}},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.022556390977443608}},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}}}},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008379888268156424}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}}},"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}}}},"3":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"docs":{}}}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"2":{"4":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},"n":{"docs":{},"i":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"e":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"x":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"l":{"docs":{"./":{"ref":"./","tf":0.013157894736842105},"TypedML.html":{"ref":"TypedML.html","tf":2.537593984962406}},"'":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"e":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.013157894736842105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007532956685499058},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"a":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}}}}}},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"u":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},"e":{"docs":{},"(":{"docs":{},"j":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018461538461538463},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}},"x":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"t":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"h":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003138731952291274},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529}}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"v":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}}}}}}}}}}}},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},"(":{"1":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},",":{"4":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"c":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.333961079723791}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"Cats.html":{"ref":"Cats.html","tf":0.009776536312849162}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"n":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}}}}}}}}}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.009060022650056626}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"$":{"2":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"8":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"6":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"1":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"9":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"$":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"1":{"0":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"0":{"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"1":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"0":{"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"2":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"3":{"8":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"$":{"docs":{},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"$":{"docs":{},"$":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"7":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"1":{"5":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"2":{"1":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"6":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"7":{"0":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"$":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"{":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},".":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"g":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},")":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"u":{"docs":{},"d":{"docs":{},"t":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}},")":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"u":{"docs":{},"d":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"j":{"docs":{},"#":{"1":{"1":{"6":{"3":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232},"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"f":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.017543859649122806},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003138731952291274}},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"o":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351783517835174}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212},"TypedML.html":{"ref":"TypedML.html","tf":0.022556390977443608},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529}},"#":{"5":{"5":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}},"/":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"b":{"docs":{},"y":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}}}}}}}}},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"3":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"4":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"5":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"7":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"9":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}},"2":{"0":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"i":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01245753114382786}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"i":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"s":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}},"(":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519}},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}},"i":{"docs":{},"v":{"docs":{},"o":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006795016987542469}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"t":{"docs":{},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0056625141562853904}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"c":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"d":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"d":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"Cats.html":{"ref":"Cats.html","tf":3.3375232774674113}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"i":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"s":{"1":{"0":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"1":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"3":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"4":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"2":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"5":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"a":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0056625141562853904}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"[":{"docs":{},"i":{"docs":{},"o":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"u":{"docs":{},"i":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"#":{"1":{"1":{"3":{"1":{"docs":{},"l":{"docs":{},",":{"docs":{},"j":{"docs":{},"#":{"1":{"1":{"3":{"2":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003138731952291274}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}},"o":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"m":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"p":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"y":{"docs":{},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"d":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.017543859649122806}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"5":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"9":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},">":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"6":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"8":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}},"docs":{}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"y":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},"z":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.02631578947368421},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.013590033975084938},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232},"Job.html":{"ref":"Job.html","tf":0.03361344537815126},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedML.html":{"ref":"TypedML.html","tf":2.5225563909774436},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01845018450184502}},"'":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5045300113250284},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},")":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"[":{"docs":{},"*":{"docs":{},"]":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"[":{"docs":{},"f":{"docs":{},"[":{"docs":{},"_":{"docs":{},"]":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"]":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}},"g":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},",":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095}}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.015065913370998116},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014760147601476014}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"l":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"e":{"docs":{},"#":{"5":{"4":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006905210295040804}}}}}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"c":{"docs":{},"h":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"[":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.012605042016806723}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"i":{"docs":{},"z":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0056625141562853904},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.021929824561403508},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.010043942247332079},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01925254813137033},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3456410256410254},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.0223463687150838},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.027675276752767528}},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.34440344403444}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"p":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.013157894736842105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005021971123666039},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.503397508493771},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedML.html":{"ref":"TypedML.html","tf":2.5225563909774436}},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3352165725047076},"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"docs":{}}}}}}}}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}},"\"":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519}}}}}}}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"[":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}},"u":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}}}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"s":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedML.html":{"ref":"TypedML.html","tf":0.022556390977443608}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"a":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.013157894736842105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012307692307692308}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"a":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}}}},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}},"p":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"2":{"3":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"docs":{}},"docs":{}}}}},"w":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"s":{"docs":{},"k":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}},"f":{"1":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"j":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"2":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"j":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}},"i":{"docs":{},"t":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}}}}}}}},"p":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{"./":{"ref":"./","tf":0.03070175438596491},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005021971123666039},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006795016987542469},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"Cats.html":{"ref":"Cats.html","tf":3.3417132216014895},"TypedML.html":{"ref":"TypedML.html","tf":2.5225563909774436},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.00922509225092251}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"'":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}},"d":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.01820464532328939},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0056625141562853904},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018461538461538463},"Injection.html":{"ref":"Injection.html","tf":0.03481012658227848},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.015363128491620111},"TypedML.html":{"ref":"TypedML.html","tf":0.03007518796992481}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},"#":{"1":{"1":{"6":{"5":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"o":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.022556390977443608}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"docs":{}}}}}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"a":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005021971123666039},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},"y":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"h":{"docs":{},"y":{"docs":{},"?":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"(":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"'":{"docs":{},"`":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"x":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"_":{"4":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"q":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"z":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"*":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006277463904582548},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"_":{"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"docs":{}}}}}}},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.12303829252981795},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.08493771234428087},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03076923076923077},"Injection.html":{"ref":"Injection.html","tf":0.06645569620253164},"Job.html":{"ref":"Job.html","tf":0.025210084033613446},"Cats.html":{"ref":"Cats.html","tf":0.04748603351955307},"TypedML.html":{"ref":"TypedML.html","tf":0.06766917293233082},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},":":{"2":{"0":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"5":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"9":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"3":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"2":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"4":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}},"4":{"5":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"6":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"8":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{}},"5":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"docs":{}},"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Cats.html":{"ref":"Cats.html","tf":0.025139664804469275}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"[":{"1":{"docs":{},".":{"0":{"docs":{},",":{"2":{"docs":{},".":{"0":{"docs":{},",":{"3":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{},".":{"docs":{},".":{"1":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"docs":{}},"docs":{}}}}},"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"x":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"_":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}}}},"docs":{}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"#":{"5":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006905210295040804}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"4":{"3":{"6":{"2":{"9":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}}},"i":{"docs":{},"#":{"1":{"1":{"3":{"1":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},",":{"docs":{},"j":{"docs":{},"#":{"1":{"1":{"3":{"2":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"[":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}}}}}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}},"^":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}},"_":{"1":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"#":{"1":{"2":{"3":{"6":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}}}},"docs":{}},"|":{"1":{"0":{"0":{"0":{"docs":{},"|":{"1":{"0":{"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"2":{"7":{"6":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"6":{"2":{"docs":{},".":{"8":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.015693659761456372},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.009060022650056626}},"[":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"4":{"5":{"docs":{},",":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"8":{"3":{"docs":{},",":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"2":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"7":{"4":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"3":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"1":{"0":{"0":{"docs":{},",":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"2":{"5":{"docs":{},",":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"5":{"0":{"docs":{},",":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"+":{"docs":{},"|":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}}}}},"$":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"1":{"4":{"docs":{},".":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"2":{"docs":{},"b":{"4":{"docs":{},"e":{"docs":{},"e":{"4":{"3":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{}},"docs":{}}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}},"&":{"docs":{},"&":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"{":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},"}":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"y":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"?":{"docs":{},"?":{"docs":{},"?":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"length":2516},"corpusTokens":["\"0.3.0\"","\"another\")))","\"daterange\"","\"dummy\"","\"e\")","\"false\")","\"frameless","\"java.util.date\",","\"jday\")","\"mydate\"","\"org.typelevel\"","\"paris\")","\"q\")","\"s\")","\"s\"))))","\"s\",","\"string\"),","\"task2\"","\"unique\"","\"w\")","$anon$1@2b4ee43","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","%","%%","&&","').map(r","'_4)","'`citi`'","'`x`'","'name),","'population)","'price),","'project","'q',","'s)","'x',","'z'))","'z'.","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(((((((((","(1,","(1,2,3)","(10,9,9)","(2,","(8,","(8,2,3)","(a","(a)","(and","(automated)","(b)","(case","(chris,map(0","(class:","(e.g.","(enjoy","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(i#1131l","(implicit","(in","(includ","(int,","(isnotnull(i#1131l)","(john,map(0","(look","(lyon,166500.0))","(manual)","(name:","(paris,333333.3333333333),","(peopl","(phonebooktf:","(sam,map(0","(sample:","(see","(semigroup)","(seq[(int,","(string,","(support","(the","(thumb","(u:","(up","(which","(with","(wrappedarray((1,string)),2)",")",").as[aptpricecity].show().run",").as[stats].show().run()",").explain()",").select(",").show().run()","*","*deserializetoobject","*filescan","*filter","*mapel","*project","*serializefromobject","+","++=","+1,","+=",",","...",".appli",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","/","//","0.13.13:","0.9.x)","09:21:38","1","1)","1))","1)),","1),","1,","1.0","1.6","1.6+,","1.6,","10","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10,","100)","100,","10000.0,","102|","10|","11","11))","12)","12,","133000.0,","133000.0|","15)))","18","1|","2","2)","2))","2)),","2),","2).as[updatedsurface]","2).show().run()","2,","2.0","2.0)","2.0,","2.0.x)","2.10,","2.11","2.11,","2.11.x.","20%","20)","20,","200000.0,","200000.0|","2017))","22.","2229621),","2229621|","2409.6385542168673,","242","25,","250000.0,","250000.0|","250|","25|[paris,","27|","2955.5555555555557,","3","3)","3))","3),","3,","300000.0,","300000.0|","32,","325000.0,","325000.0|","343629)","343629|","4","4))","4)),","4,","434","4391.891891891892)","4391.891891891892|","45,","4500.0,","450000.0,","450000.0|","450|","454","47|","5,","50,","500715),","500715|","500|","52|","6,","6833.333333333333|","74,","740|","76|","778","83,","830|","85|",":",":20:",":24:",":25:",":27:",":28:",":29:",":31:",":32:",":33:",":34:",":36:",":45",":46",":48",":50","::",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","==","===","=>",">",">=","???","['citi]","['x]","[1...10]).","[1.0,2.0,3.0]","[],","[_1:","[age:","[city#53,","[city,","[city:","[i#1131l","[i#1131l,j#1132]","[i#1131l]","[i,","[i:","[input[0,","[isnotnull(i),","[lyon,500715]|","[nice,343629]|","[out](other:","[ratio:","^","_1#1236l]","_1|","_2:","_2|","a):","abil","abov","above)","above,","above.","abstract","access","achiev","act","action","action[(seq[(int,","action[t]","actual","ad","add","addit","address","address,","address:","adelbertc","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","against","agg()","agg(avg(aptds('price))).","aggreg","aggregated,","agree.","algebra","alia","alias","align.","allcities:","allcities|","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","allowed,","allowed.","along","alphabet:","alternatively,","alternatives:","amount","and/or","anna","annotate/nam","annoy","anoth","apach","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartmentdetail","apartmentdetails(city:","apartmentdetails?","api","api:","appear","appli","applic","applications.","apply(a:","apply(d:","approach","approxim","aptd","aptds('price)","aptds('price)))","aptds('price),","aptds('surface))","aptds('surface)).as[apartmentdetails]","aptds('surface),","aptds.","aptds.agg(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)).as[updatedsurface]","apttypedds('city),","apttypedds('city).cast[double]","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.join(citiinfotypedds,","apttypedds.makeudf(pricemodifier)","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds2","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","are:","area","argument","arguments)","ariti","arity.","around","array((joe,map(0","array(1,","array[(username,","as:","as[bedroomstats]","as[long]","as[t]","associ","assum","at[long]","avail","available,","available.","averag","avg(aptds('price)),","avg(aptds('surface)),","avg,","avgprice:","avgpricebeds1:","avgpricebeds2:","avgpricebeds3:","avgpricebeds4:","avgprice|","avgsurface:","avgsurface|minsurface|","avoid","away:","b","b):","b.","b:","b]","bar","bar(1)))","bar(1.1,","bar(d:","bar(i:","bar)","bardate(1.1,","bardate(d:","bardate)","base","batched:","be","bedroom","bedrooms#56]","bedrooms.","bedrooms:","bedrooms];;","bedroomstat","bedroomstats(","bedroomstats(lyon,some(133000.0),some(200000.0),none,none)","bedroomstats(nice,none,none,some(325000.0),none)","bedroomstats(paris,some(250000.0),some(300000.0),some(450000.0),none)","bedroomstats.collect().run().foreach(println)","bedroomstats.show().run()","bedroomstats:","before.","begin","behav","below","benefit","besid","bestneighborhood","better","between","bigint","bigint))","bigint,","bigint]","bind","birthday:","block","boolean","boolean)","boolean):","boolean)]","boolean)].","boolean,","bootstrap","both","break","bring","bug","build.sbt","built","bulletproof:","c:","calcul","call","can't","can't,","capabl","captur","care","case","case.","cast","cast(10","cast,","cat","catalyst","catalystcast.","catalystcast[string,","catch","cats\"","cats.data.readert","cats.effect.implicits._","cats.effect.io","cats.effect.sync","cats.effect.sync[f].","cats.implicit","cats.implicits._","cats.mtl.implicits._","cats:","caus","chang","channel","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name))","city:","cityinfo","cityinfo(city:","citymapentry(","citymaptf:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|avgpricebeds1|avgpricebeds2|avgpricebeds3|avgpricebeds4|","city|surface|","class","class:","classes)","classes.","clause.","clearli","closur","closures.","code","code.","collect","collectset(aptds('city))","column","column.","column:","columnar","columns,","columns.","columns:","combin","come","common","commonli","companion","compar","comparison,","compat","compil","compile.","compile:","compiles:","complet","complex","compos","composit","comprehens","compromis","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","concept","concept:","conduct","conf","consid","consist","consol","construct","constructor","contain","content","context","continu","contribut","contributor","conveni","correct","correct.","correctli","correspond","cough","count","count:","countandtakejob","coupl","creat","current","currently,","custom","customizable,","d.gettime()","d:","data","data,","data.","data:","datafram","dataframe,","dataframes,","dataset","dataset\"","dataset.","dataset:","dataset?.","dataset[daterange]","dataset[long].","datasets,","daterange(s:","datetolonginject","datetolonginjection:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","decod","def","default","defin","definit","delay","depend","deprec","deriv","derived,","descript","description.","description:","design","detail","detail.","detect","develop","differ","different,","directli","discuss","discussion.","disk","dive","divid","document","documented.","doesn't","domain","done","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","ds","ds.collect()","ds.filter($\"i\"","ds.filter(_.i","ds.show()","ds:","due","e:","each","earli","easi","easier","easili","effect","effect:","effects.","element","elements:","elid","encod","encoder.","encoder:","encoders,","enhanc","enough","enrich","ensur","entir","environ","equalto(i,10)],","error","error.","error:","essenti","etc)","etc.","eventu","everyth","evid","exactli","exampl","example,","example.","example:","except","execut","exist","expect","expected:","expens","explain","explan","explicit","explicitli","express","extend","extra","extrem","e|","f","f.neighborhood))","f.residents.split('","f[_]","f[_],","f[a]","f[a],","fact","fail","failure:","false]","familiar","family(residents:","family:","fanci","fd","fds('i)","fds('x)","fds.filter(","fds:","featur","femal","few","field","fields.","fields]","file","file.","filter","filter(conditionexpr:","filteredd","filteredds.explain()","filteredds.show()","filteredds:","finaljob","finaljob.","finaljob:","find","first","first,","five","flat","focu","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo(s:","foo,","foo.","foodate(i:","form","format","format:","found","frameless","frameless'","frameless.","frameless._","frameless.catalystcast[string,double]","frameless.catalystdivisible[double,out],","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.cats.implicits.","frameless.cats.implicits._","frameless.cats.implicits._.","frameless.cats.outer._","frameless.functions.aggregate._","frameless.implicits.widen._","frameless.injection$$anon$1@5a548922","frameless.injection$$anon$1@62c73008","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.job","frameless.job$$anon$2@6ef768bf","frameless.job$$anon$4@208e2282","frameless.job[int]","frameless.job[seq[foo]]","frameless.job[seq[int]])frameless.job[int]","frameless.ml._","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[apartment,double])(implicit","frameless.typeddatafram","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(int,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[bedroomstats]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[foo]","frameless.typeddataset[int]","frameless.typeddataset[person]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless.typedencoder[mydate]","frameless.typedencoder[out])frameless.typedcolumn[apartment,out]","frameless.typedencoder[person]","frameless:","framelessvers","framelessversion,","friend.","friendli","full","fulli","function","function:","functions:","further","futur","g8","gender","gender)","gender:","gendertoint:","gener","general).","generated.","get","giter8","github,","gitter)","give","given","go","goal","goal:","goe","great!","ground,","group","groupbi","groupby()","groupby(aptds('city)).","guard","handhold","handl","have","help","here","here.","here:","hierarchi","hold","hood,","however,","http://opensource.org/licenses/apach","i:","id","ident","if(nam","imario","imarios/frameless.g8","implement","implicit","implicitli","implicits.scala:18","implicits.scala:43","import","improv","inabl","incompat","inform","initi","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","inmemoryfileindex[file:/tmp/foo],","input","insid","instal","instanc","instance.","instances:","instanti","instead","int","int)","int).","int)]","int,","int.","int]","integr","interest","intermedi","intern","introduc","introduct","intuitively,","invert(b:","invert(l:","io","issues.","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date(system.currenttimemillis))))","java.util.date)","java.util.date))","java.util.date)))","java.util.date))))","java.util.date).gettime(),","java.util.date):","java.util.date,","java.util.date.","jeremyrsmith","job","job,","job[a]","job[int]","job[seq[int]]):","jobs.","joe","join","join1(tf1:","join2(tf1:","joins,","jvm","j|","kanterov","keep","kernel","key","key.","keys.","know","languag","larg","last","layer","lazi","lazili","lazy,","lazy.","lead","learning.","less","let","let'","letter","level","leverag","librari","library:","librarydepend","licens","lift","like,","limit","limitations.","line","linear","linux","list(","list(person(42,male))","list(person(42,w","load","local","localrel","location:","long","long)","long)))","long):","long)]","long)])","long,","long:","long]","look","lyon]|","lyon|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","mac","machineri","macro","made","main","maintain","make","makerdd","male","male))","manag","manipul","manner.","map","map(\"task1\"","map(\"task3\"","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[24]","mapvalu","materialize.","math","matrices.dense(2,","matrix","matrix))","matrix:","matrix]","matrixd","matrixds:","matter","max,","meaning","mechan","member","members.","mention","merg","method","method.","min\").","min(aptds('surface)),","min,","minimum","minsurface:","mirror","miss","missing,","misspel","mistak","ml","ml'","model","moder","modifi","modul","module,","modules:","monad","more","mtl","much","mydat","mydate(jday:","n","n:","name","name.exists(set('x',","name:","namely,","names,","natur","need","needed:","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","new","newinstance(class","next","next,","nice,","nice|","nice|325000.0|","nil","nil)","nlplib","nlplib.uniquename(p.name)","non","normal","not,","note","noth","notifi","now","now,","null|","number","number,","obj#1163:","obj#1164:","object","object.","obtain","obviou","oct","of)","offer","ok","olivierblanvillain","on","on(1,2,3,4).","onc","ontypeddataframe.","onward.","open","oper","operations:","optim","optimizer)","option","option.","option[double])","option[double],","order","org.apache.spark.ml.linalg._","org.apache.spark.ml.linalg.matrix","org.apache.spark.ml.linalg.matrix)]","org.apache.spark.ml.linalg.matrix:","org.apache.spark.ml.linalg.matrixudt.","org.apache.spark.ml.linalg.vector","org.apache.spark.ml.linalg.vector)]","org.apache.spark.ml.linalg.vectorudt","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:88)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:71)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$6.apply(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1$1.apply(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$transformexpressionsup$1.apply(queryplan.scala:268)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:289)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:268)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$10.apply(scalareflection.scala:607)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$10.apply(scalareflection.scala:619)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:607)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:625)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:438)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:70)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:289)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:127)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:187)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:288)","org.apache.spark.sql.datafram","org.apache.spark.sql.dataset","org.apache.spark.sql.dataset$.ofrows(dataset.scala:66)","org.apache.spark.sql.dataset.(dataset.scala:164)","org.apache.spark.sql.dataset.(dataset.scala:170)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2872)","org.apache.spark.sql.dataset.select(dataset.scala:1153)","org.apache.spark.sql.dataset.select(dataset.scala:1213)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:275)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:52)","org.apache.spark.sql.lowprioritysqlimplicits$class.newproductencoder(sqlimplicits.scala:233)","org.apache.spark.sql.sparksess","org.apache.spark.sql.sqlcontext","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:33)","org.apache.spark.sql.types.userdefinedtype[a]","org.apache.spark.{sparkconf,","os","outer","over","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","overflow","overload","overview","p","packag","pair","parallelcollectionrdd[14]","parallelcollectionrdd[15]","parallelcollectionrdd[17]","parallelcollectionrdd[19]","parallelcollectionrdd[20]","paramet","parquet","parquet,","part","partial","particular","partitionfilters:","pass","pdt","peopl","people:","per","perform","performance.","performances.","perhap","person","person(age:","person(name:","person(r,","persond","personds:","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","physic","pivot","pivot(aptds('bedrooms)).","pivot,","place","plain","plan","plan,","plan.","plan:","point,","popul","popular","population:","possibl","potenti","practic","pre","precis","predicates.","predict","prefer","preserv","previous","price","price#55,","price,","price/surfac","price:","price:double)","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.collect.run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","primit","println(data.cmax)","println(data.cmin)","println(data.csum)","problem","problem.","proce","process","product","product,","product.","program","program,","programm","project","project:","proof","properli","prove","provid","public","pull","pushedfilters:","queri","question","quick","q|","r","rais","ratio","ratio:","ratio|","rdd","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","read","readability.","readabl","readert","readert[io,","readi","readschema).","readschema:","reasons,","recurs","reducebykey","refer","referenc","reflect","relation[i#1131l,j#1132]","releases.","remind","repl\").set(\"spark.ui.enabled\",","repres","represent","request","requests)","requests.","requir","res10:","res11:","res13:","res14:","res17:","res2:","res5:","res6:","res7:","residents:","resolut","resolv","resolver.sonatyperepo(\"releases\")","result","result.run(spark).unsaferunsync()","result:","resultwithdescription.run(spark).unsaferunsync()","resultwithdescription:","rethought","retriev","return","right","right?","root","row","run","run()","run:","runtim","s:","sadly,","safe","safe,","safe.","safety!","safety,","safety.","same","sampl","sample.map(_.min)","save","say,","sbt","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala","scala.","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.immutable.map[string,int])]","scala.collection.map[string,scala.collection.immutable.map[string,int]]","scala.collection.map[user,transactioncount]","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala>","scalareflect","schema","schema.","seal","second","second,","secondari","section","see","see,","seem","select","select()","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","selectmany()","selectmany,","semigroup","separately,","seq(","seq(person(42,","seq[(string,","seq[double]","seq[person]","sequenc","serial","serializ","serv","set","sever","shadow","shapeless","shapeless.hlist","shapeless.tag.tagged[string(\"citi\")]","shapeless.tag.tagged[string(\"x\")]","shell","shorter","show","show()","showcas","shown","shuffledrdd[16]","shuffledrdd[18]","sign","signatur","signatures:","similar","similar)","simpl","simplifi","simplist","simply:","singl","situat","size","skip","slow","small","solut","solv","sort","spark","spark'","spark).","spark,","spark.","spark.createdataset(","spark.createdataset(apartments)","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark.sparkcontext.setloglevel(\"warn\")","spark.sqlcontext","spark:","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparkdelay","sparkdelay[f[_]]","sparkdelay[f].","sparksess","sparksession,","sparksession.","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","sqlcontext","sqlcontext):","sqlcontext.createdataset(seq(daterange(new","stack","stack.","stack:","stage","standard","start","stat","statement","statement).","stats(","still","store","strict","string","string)","string),updatedsurface]","string):","string)]","string)])","string)],","string,","string.","string]","strongli","struct","struct,","struct]","subset","such","suffici","suggests,","summari","suppli","support","suppos","surfac","surface#54,","surface,","surface,th","surface:","suspend","suspended.","suspens","symbol","syntax","syntax.","syntax:","syntaxes,","system","systems,","t","t:","t]","tabl","table,","tables:","take","target","task","task2","task3","tdataframe[schema","tdataframe[schema]","techniqu","tell","ten","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","thank","thing","this.","thought","thread","three","thunk","time","time,","time.","time:","timeseri","timeseries)]","togeth","together.","top","totalperus","totalperuser.collectasmap","totalperuser:","toy","trace):","trace,","track","track,","trait","transactioncount","transactioncount)]","transform","tri","troubl","true,","tupl","tuple23","tutori","two","type","type,","type.","type:","typeclass","typeclass,","typeclass:","typedcolumn","typedd","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry]","typeddataframe[citymapentry])","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","typeddataset","typeddataset,","typeddataset.","typeddataset.create(1","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset.create(ds)","typeddataset.create(people)","typeddataset.create(seq(\"label\"","typeddataset.create(seq((1,","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset.create(seq(mydate(new","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","typeddatset","typedds:","typedencod","typedencoder[a]","typeencod","typelevel","types,","types.","types:","typesaf","typesafeti","typo","typo,","u","udf","udf(aptds('city),","udf:","ui","unabl","under","unfortunately,","uniqu","uniquename(name:","unit:","unlik","unsaf","up","up,","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","user'","usernam","util","val","valid","valu","value#1165l]","value,","vanilla","variabl","variou","vector","vector))","vector:","vector[string])","vector]","vectord","vectords:","vectors.dense(1,","verbos","veri","version","versions.","via","view","want","way","well","well,","wherea","why?","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withdescription(\"sampl","withgroupid(\"samplingjob\").","without","won't","work","work,","worked,","wrap","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","w|","x","x:","yet.","zero.","{","|","|+|","|1000|102|","|100|","|276333.3333333333|62.833333333333336|","|4500.0|450000.0|","|6000.0|300000.0|","|[lyon,45,133000.0,1]|","|[lyon,83,200000.0,2]|","|[nice,74,325000.0,3]|","|[paris,100,450000...|[paris,2229621]|","|[paris,25,250000....|[paris,2229621]|","|[paris,50,300000....|[paris,2229621]|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|value|","}","})","},"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"Introduction","keywords":"","body":"Frameless\n\n\n\n\nFrameless is a proof-of-concept library for working with Spark using more expressive types.\nIt consists of the following modules:\n\ndataset for more strongly typed Datasets (supports Spark 2.0.x)\ncats for using Spark with cats (supports Cats 0.9.x)\nml for a more strongly typed use of Spark ML based on dataset\n\nThe Frameless project and contributors support the\nTypelevel Code of Conduct and want all its\nassociated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning.\nDocumentation\n\nTypedDataset: Feature Overview\nComparing TypedDatasets with Spark's Datasets\nTyped Encoders in Frameless\nInjection: Creating Custom Encoders\nJob[A]\nUsing Cats with RDDs\nTypedDataset support for Spark ML\nProof of Concept: TypedDataFrame\n\nWhy?\nBenefits of using TypedDataset compared to the standard Spark Dataset API:\n\nTypesafe columns referencing and expressions\nCustomizable, typesafe encoders\nTypesafe casting and projections\nEnhanced type signature for some built-in functions\n\nQuick Start\nFrameless is compiled against Scala 2.11.x.\nNote that while Frameless is still getting off the ground, it is very possible that breaking changes will be\nmade for at least the next few versions.\nTo use Frameless in your project add the following in your build.sbt file as needed:\nresolvers += Resolver.sonatypeRepo(\"releases\")\n\nval framelessVersion = \"0.3.0\"\n\nlibraryDependencies ++= List(\n \"org.typelevel\" %% \"frameless-cats\" % framelessVersion,\n \"org.typelevel\" %% \"frameless-dataset\" % framelessVersion\n)\n\nAn easy way to bootstrap a Frameless sbt project:\n\nif you have Giter8 installed then simply:\n\ng8 imarios/frameless.g8\n\n\nwith sbt >= 0.13.13:\n\nsbt new imarios/frameless.g8\n\nTyping sbt console inside your project will bring up a shell with Frameless\nand all its dependencies loaded (including Spark).\nDevelopment\nWe require at least one sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers\n(people who can merge pull requests) are:\n\nadelbertc\nimarios\njeremyrsmith\nkanterov\nnon\nOlivierBlanvillain\n\nLicense\nCode is provided under the Apache 2.0 license available at http://opensource.org/licenses/Apache-2.0,\nas well as in the LICENSE file. This is the same license used as Spark.\n"},"FeatureOverview.html":{"url":"FeatureOverview.html","title":"TypedDataset: Feature Overview","keywords":"","body":"TypedDataset: Feature Overview\nThis tutorial introduces TypedDataset using a simple example.\nThe following imports are needed to make all code examples compile.\nimport org.apache.spark.{SparkConf, SparkContext}\nimport org.apache.spark.sql.SparkSession\nimport frameless.functions.aggregate._\nimport frameless.TypedDataset\n\nval conf = new SparkConf().setMaster(\"local[*]\").setAppName(\"frameless repl\").set(\"spark.ui.enabled\", \"false\")\nval spark = SparkSession.builder().config(conf).appName(\"REPL\").getOrCreate()\nimplicit val sqlContext = spark.sqlContext\nspark.sparkContext.setLogLevel(\"WARN\")\n\nimport spark.implicits._\n\nCreating TypedDataset instances\nWe start by defining a case class:\ncase class Apartment(city: String, surface: Int, price: Double, bedrooms: Int)\n\nAnd few Apartment instances:\nval apartments = Seq(\n Apartment(\"Paris\", 50, 300000.0, 2),\n Apartment(\"Paris\", 100, 450000.0, 3),\n Apartment(\"Paris\", 25, 250000.0, 1),\n Apartment(\"Lyon\", 83, 200000.0, 2),\n Apartment(\"Lyon\", 45, 133000.0, 1),\n Apartment(\"Nice\", 74, 325000.0, 3)\n)\n\nWe are now ready to instantiate a TypedDataset[Apartment]:\nval aptTypedDs = TypedDataset.create(apartments)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nWe can also create one from an existing Spark Dataset:\nval aptDs = spark.createDataset(apartments)\n// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval aptTypedDs = TypedDataset.create(aptDs)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nOr use the Frameless syntax:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval aptTypedDs2 = aptDs.typed\n// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nTypesafe column referencing\nThis is how we select a particular column from a TypedDataset:\nval cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))\n// cities: frameless.TypedDataset[String] = [_1: string]\n\nThis is completely type-safe, for instance suppose we misspell city as citi:\naptTypedDs.select(aptTypedDs('citi))\n// :28: error: No column Symbol with shapeless.tag.Tagged[String(\"citi\")] of type A in Apartment\n// aptTypedDs.select(aptTypedDs('citi))\n// ^\n\nThis gets raised at compile-time, whereas with the standard Dataset API the error appears at run-time (enjoy the stack trace):\naptDs.select('citi)\n// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [city, surface, price, bedrooms];;\n// 'Project ['citi]\n// +- LocalRelation [city#53, surface#54, price#55, bedrooms#56]\n// \n// at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:88)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:85)\n// at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n// at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n// at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:70)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:288)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:279)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:289)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1$1.apply(QueryPlan.scala:293)\n// at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n// at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n// at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)\n// at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)\n// at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n// at scala.collection.AbstractTraversable.map(Traversable.scala:104)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:293)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$6.apply(QueryPlan.scala:298)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:187)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:298)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:268)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:85)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)\n// at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)\n// at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:66)\n// at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2872)\n// at org.apache.spark.sql.Dataset.select(Dataset.scala:1153)\n// ... 434 elided\n\nselect() supports arbitrary column operations:\naptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()\n// +----+---+\n// | _1| _2|\n// +----+---+\n// | 500| 52|\n// |1000|102|\n// | 250| 27|\n// | 830| 85|\n// | 450| 47|\n// | 740| 76|\n// +----+---+\n//\n\nNote that unlike the standard Spark API where some operations are lazy and some are not, TypedDatasets have all operations to be lazy. \nIn the above example, show() is lazy. It requires to apply run() for the show job to materialize.\nA more detailed explanation of Job is given here.\nNext we compute the price by surface unit:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// :27: error: overloaded method value / with alternatives:\n// (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] \n// [Out](other: frameless.TypedColumn[Apartment,Double])(implicit n: frameless.CatalystDivisible[Double,Out], implicit e: frameless.TypedEncoder[Out])frameless.TypedColumn[Apartment,Out]\n// cannot be applied to (frameless.TypedColumn[Apartment,Int])\n// val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// ^\n\nAs the error suggests, we can't divide a TypedColumn of Double by Int. \nFor safety, in Frameless only math operations between same types is allowed. \nThere are two ways to proceed here: \n(a) Explicitly cast Int to Double (manual)\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect().run()\n// res6: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\n(b) Perform the cast implicitly (automated)\nimport frameless.implicits.widen._\n// import frameless.implicits.widen._\n\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect.run()\n// res7: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\nLooks like it worked, but that cast seems unsafe right? Actually it is safe.\nLet's try to cast a TypedColumn of String to Double:\naptTypedDs('city).cast[Double]\n// :31: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]\n// aptTypedDs('city).cast[Double]\n// ^\n\nThe compile-time error tells us that to perform the cast, an evidence \n(in the form of CatalystCast[String, Double]) must be available. \nSince casting from String to Double is not allowed, this results \nin a compilation error. \nCheck here \nfor the set of available CatalystCast.\nTypeSafe TypedDataset casting and projections\nWith select() the resulting TypedDataset is of type TypedDataset[TupleN[...]] (with N in [1...10]).\nFor example, if we select three columns with types String, Int, and Boolean the result will have type\nTypedDataset[(String, Int, Boolean)]. To select more than ten columns use the selectMany() method. \nSelect has better IDE support than the macro based selectMany, so prefer select() for the general case. \nWe often want to give more expressive types to the result of our computations.\nas[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long\nas the types in U and T align.\nWhen the cast is valid the expression compiles:\ncase class UpdatedSurface(city: String, surface: Int)\n// defined class UpdatedSurface\n\nval updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]\n// updated: frameless.TypedDataset[UpdatedSurface] = [city: string, surface: int]\n\nupdated.show(2).run()\n// +-----+-------+\n// | city|surface|\n// +-----+-------+\n// |Paris| 52|\n// |Paris| 102|\n// +-----+-------+\n// only showing top 2 rows\n//\n\nNext we try to cast a (String, String) to an UpdatedSurface (which has types String, Int).\nThe cast is not valid and the expression does not compile:\naptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// :33: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]\n// aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// ^\n\nProjections\nWe often want to work with a subset of the fields in a dataset.\nProjections allows to easily select the fields we are interested\nwhile preserving their initial name and types for extra safety.\nHere is an example using the TypedDataset[Apartment] with an additional column:\nimport frameless.implicits.widen._\n// import frameless.implicits.widen._\n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\ncase class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)\n// defined class ApartmentDetails\n\nval aptWithRatio = aptds.select(aptds('city), aptds('price), aptds('surface), aptds('price) / aptds('surface)).as[ApartmentDetails]\n// aptWithRatio: frameless.TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]\n\nSuppose we only want to work with city and ratio:\ncase class CityInfo(city: String, ratio: Double)\n// defined class CityInfo\n\nval cityRatio = aptWithRatio.project[CityInfo]\n// cityRatio: frameless.TypedDataset[CityInfo] = [city: string, ratio: double]\n\ncityRatio.show(2).run()\n// +-----+------+\n// | city| ratio|\n// +-----+------+\n// |Paris|6000.0|\n// |Paris|4500.0|\n// +-----+------+\n// only showing top 2 rows\n//\n\nSuppose we only want to work with price and ratio:\ncase class PriceInfo(ratio: Double, price: Double)\n// defined class PriceInfo\n\nval priceInfo = aptWithRatio.project[PriceInfo]\n// priceInfo: frameless.TypedDataset[PriceInfo] = [ratio: double, price: double]\n\npriceInfo.show(2).run()\n// +------+--------+\n// | ratio| price|\n// +------+--------+\n// |6000.0|300000.0|\n// |4500.0|450000.0|\n// +------+--------+\n// only showing top 2 rows\n//\n\nWe see that the order of the fields does not matter as long as the\nnames and the corresponding types agree. However, if we make a mistake in\nany of the names and/or their types, then we get a compilation error.\nSay we make a typo in a field name:\ncase class PriceInfo2(ratio: Double, pricEE: Double)\n\naptWithRatio.project[PriceInfo2]\n// :36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?\n// aptWithRatio.project[PriceInfo2]\n// ^\n\nSay we make a mistake in the corresponding type:\ncase class PriceInfo3(ratio: Int, price: Double) // ratio should be Double\n\naptWithRatio.project[PriceInfo3]\n// :36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?\n// aptWithRatio.project[PriceInfo3]\n// ^\n\nUser Defined Functions\nFrameless supports lifting any Scala function (up to five arguments) to the\ncontext of a particular TypedDataset:\n// The function we want to use as UDF\nval priceModifier =\n (name: String, price:Double) => if(name == \"Paris\") price * 2.0 else price\n// priceModifier: (String, Double) => Double = \n\nval udf = aptTypedDs.makeUDF(priceModifier)\n// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = \n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))\n// adjustedPrice: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\nadjustedPrice.show().run()\n// +-----+--------+\n// | _1| _2|\n// +-----+--------+\n// |Paris|600000.0|\n// |Paris|900000.0|\n// |Paris|500000.0|\n// | Lyon|200000.0|\n// | Lyon|133000.0|\n// | Nice|325000.0|\n// +-----+--------+\n//\n\nGroupBy and Aggregations\nLet's suppose we wanted to retrieve the average apartment price in each city\nval priceByCity = aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('price)))\n// priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\npriceByCity.collect().run()\n// res17: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))\n\nAgain if we try to aggregate a column that can't be aggregated, we get a compilation error\naptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city))) \n// :34: error: Cannot compute average of type String.\n// aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))\n// ^\n\nNext, we combine select and groupBy to calculate the average price/surface ratio per city:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval cityPriceRatio = aptds.select(aptds('city), aptds('price) / aptds('surface))\n// cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\ncityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()\n// +-----+------------------+\n// | _1| _2|\n// +-----+------------------+\n// | Nice| 4391.891891891892|\n// |Paris| 6833.333333333333|\n// | Lyon|2682.5970548862115|\n// +-----+------------------+\n//\n\nWe can also use pivot to further group data on a secondary column. \nFor example, we can compare the average price across cities by number of bedrooms. \ncase class BedroomStats(\n city: String, \n AvgPriceBeds1: Option[Double], // Pivot values may be missing, so we encode them using Options\n AvgPriceBeds2: Option[Double], \n AvgPriceBeds3: Option[Double], \n AvgPriceBeds4: Option[Double])\n// defined class BedroomStats\n\nval bedroomStats = aptds.\n groupBy(aptds('city)).\n pivot(aptds('bedrooms)).\n on(1,2,3,4). // We only care for up to 4 bedrooms\n agg(avg(aptds('price))).\n as[BedroomStats] // Typesafe casting\n// bedroomStats: frameless.TypedDataset[BedroomStats] = [city: string, AvgPriceBeds1: double ... 3 more fields]\n\nbedroomStats.show().run()\n// +-----+-------------+-------------+-------------+-------------+\n// | city|AvgPriceBeds1|AvgPriceBeds2|AvgPriceBeds3|AvgPriceBeds4|\n// +-----+-------------+-------------+-------------+-------------+\n// | Nice| null| null| 325000.0| null|\n// |Paris| 250000.0| 300000.0| 450000.0| null|\n// | Lyon| 133000.0| 200000.0| null| null|\n// +-----+-------------+-------------+-------------+-------------+\n//\n\nWith pivot, collecting data preserves typesafety by \nencoding potentially missing columns with Option.\nbedroomStats.collect().run().foreach(println)\n// BedroomStats(Nice,None,None,Some(325000.0),None)\n// BedroomStats(Paris,Some(250000.0),Some(300000.0),Some(450000.0),None)\n// BedroomStats(Lyon,Some(133000.0),Some(200000.0),None,None)\n\nEntire TypedDataset Aggregation\nWe often want to aggregate the entire TypedDataset and skip the groupBy() clause.\nIn Frameless you can do this using the agg() operator directly on the TypedDataset. \nIn the following example, we compute the average price, the average surface,the minimum surface, and the set of cities for the entire dataset. \ncase class Stats(\n avgPrice: Double, \n avgSurface: Double, \n minSurface: Int, \n allCities: Vector[String])\n// defined class Stats\n\naptds.agg(\n avg(aptds('price)), \n avg(aptds('surface)),\n min(aptds('surface)),\n collectSet(aptds('city))\n).as[Stats].show().run() \n// +-----------------+------------------+----------+-------------------+\n// | avgPrice| avgSurface|minSurface| allCities|\n// +-----------------+------------------+----------+-------------------+\n// |276333.3333333333|62.833333333333336| 25|[Paris, Nice, Lyon]|\n// +-----------------+------------------+----------+-------------------+\n//\n\nJoins\ncase class CityPopulationInfo(name: String, population: Int)\n\nval cityInfo = Seq(\n CityPopulationInfo(\"Paris\", 2229621),\n CityPopulationInfo(\"Lyon\", 500715),\n CityPopulationInfo(\"Nice\", 343629)\n)\n\nval citiInfoTypedDS = TypedDataset.create(cityInfo)\n\nHere is how to join the population information to the apartment's dataset.\nval withCityInfo = aptTypedDs.join(citiInfoTypedDS, aptTypedDs('city), citiInfoTypedDS('name))\n// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct, _2: struct]\n\nwithCityInfo.show().run()\n// +--------------------+---------------+\n// | _1| _2|\n// +--------------------+---------------+\n// |[Paris,50,300000....|[Paris,2229621]|\n// |[Paris,100,450000...|[Paris,2229621]|\n// |[Paris,25,250000....|[Paris,2229621]|\n// |[Lyon,83,200000.0,2]| [Lyon,500715]|\n// |[Lyon,45,133000.0,1]| [Lyon,500715]|\n// |[Nice,74,325000.0,3]| [Nice,343629]|\n// +--------------------+---------------+\n//\n\nThe joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].\nWe can then select which information we want to continue to work with:\ncase class AptPriceCity(city: String, aptPrice: Double, cityPopulation: Int)\n// defined class AptPriceCity\n\nwithCityInfo.select(\n withCityInfo.colMany('_2, 'name), withCityInfo.colMany('_1, 'price), withCityInfo.colMany('_2, 'population)\n).as[AptPriceCity].show().run\n// +-----+--------+--------------+\n// | city|aptPrice|cityPopulation|\n// +-----+--------+--------------+\n// |Paris|300000.0| 2229621|\n// |Paris|450000.0| 2229621|\n// |Paris|250000.0| 2229621|\n// | Lyon|200000.0| 500715|\n// | Lyon|133000.0| 500715|\n// | Nice|325000.0| 343629|\n// +-----+--------+--------------+\n//\n\n"},"TypedDatasetVsSparkDataset.html":{"url":"TypedDatasetVsSparkDataset.html","title":"Comparing TypedDatasets with Spark's Datasets","keywords":"","body":"Comparing TypedDatasets with Spark's Datasets\nGoal:\n This tutorial compares the standard Spark Datasets api with the one provided by\n frameless' TypedDataset. It shows how TypedDatsets allows for an expressive and\n type-safe api with no compromises on performance.\nFor this tutorial we first create a simple dataset and save it on disk as a parquet file.\nParquet is a popular columnar format and well supported by Spark.\nIt's important to note that when operating on parquet datasets, Spark knows that each column is stored\nseparately, so if we only need a subset of the columns Spark will optimize for this and avoid reading\nthe entire dataset. This is a rather simplistic view of how Spark and parquet work together but it\nwill serve us well for the context of this discussion.\nimport spark.implicits._\n// import spark.implicits._\n\n// Our example case class Foo acting here as a schema\ncase class Foo(i: Long, j: String)\n// defined class Foo\n\n// Assuming spark is loaded and SparkSession is bind to spark\nval initialDs = spark.createDataset( Foo(1, \"Q\") :: Foo(10, \"W\") :: Foo(100, \"E\") :: Nil )\n// initialDs: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\n// Assuming you are on Linux or Mac OS\ninitialDs.write.parquet(\"/tmp/foo\")\n\nval ds = spark.read.parquet(\"/tmp/foo\").as[Foo]\n// ds: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\nds.show()\n// +---+---+\n// | i| j|\n// +---+---+\n// | 1| Q|\n// | 10| W|\n// |100| E|\n// +---+---+\n//\n\nThe value ds holds the content of the initialDs read from a parquet file.\nLet's try to only use field i from Foo and see how Spark's Catalyst (the query optimizer)\noptimizes this.\n// Using a standard Spark TypedColumn in select()\nval filteredDs = ds.filter($\"i\" === 10).select($\"i\".as[Long])\n// filteredDs: org.apache.spark.sql.Dataset[Long] = [i: bigint]\n\nfilteredDs.show()\n// +---+\n// | i|\n// +---+\n// | 10|\n// +---+\n//\n\nThe filteredDs is of type Dataset[Long]. Since we only access field i from Foo the type is correct.\nUnfortunately, this syntax requires handholding by explicitly setting the TypedColumn in the select statement\nto return type Long (look at the as[Long] statement). We will discuss this limitation next in more detail.\nNow, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.\nfilteredDs.explain()\n// == Physical Plan ==\n// *Project [i#1131L]\n// +- *Filter (isnotnull(i#1131L) && (i#1131L = 10))\n// +- *FileScan parquet [i#1131L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nThe last line is very important (see ReadSchema). The schema read\nfrom the parquet file only required reading column i without needing to access column j.\nThis is great! We have both an optimized query plan and type-safety!\nUnfortunately, this syntax is not bulletproof: it fails at run-time if we try to access\na non existing column x:\nscala> ds.filter($\"i\" === 10).select($\"x\".as[Long])\norg.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];;\n'Project ['x]\n+- Filter (i#1131L = cast(10 as bigint))\n +- Relation[i#1131L,j#1132] parquet\n\n at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:88)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:85)\n at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:70)\n at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:288)\n at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:279)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:289)\n at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1$1.apply(QueryPlan.scala:293)\n at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n at scala.collection.immutable.List.foreach(List.scala:392)\n at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n at scala.collection.immutable.List.map(List.scala:296)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:293)\n at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$6.apply(QueryPlan.scala:298)\n at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:187)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:298)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:268)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:85)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)\n at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)\n at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)\n at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)\n at org.apache.spark.sql.Dataset.(Dataset.scala:164)\n at org.apache.spark.sql.Dataset.(Dataset.scala:170)\n at org.apache.spark.sql.Dataset.select(Dataset.scala:1213)\n ... 454 elided\n\nThere are two things to improve here. First, we would want to avoid the at[Long] casting that we are required\nto type for type-safety. This is clearly an area where we can introduce a bug by casting to an incompatible\ntype. Second, we want a solution where reference to a\nnon existing column name fails at compilation time.\nThe standard Spark Dataset can achieve this using the following syntax.\nds.filter(_.i == 10).map(_.i).show()\n// +-----+\n// |value|\n// +-----+\n// | 10|\n// +-----+\n//\n\nThis looks great! It reminds us the familiar syntax from Scala.\nThe two closures in filter and map are functions that operate on Foo and the\ncompiler will helps us capture all the mistakes we mentioned above.\nscala> ds.filter(_.i == 10).map(_.x).show()\n:20: error: value x is not a member of Foo\n ds.filter(_.i == 10).map(_.x).show()\n ^\n\nUnfortunately, this syntax does not allow Spark to optimize the code.\nds.filter(_.i == 10).map(_.i).explain()\n// == Physical Plan ==\n// *SerializeFromObject [input[0, bigint, false] AS value#1165L]\n// +- *MapElements , obj#1164: bigint\n// +- *Filter .apply\n// +- *DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#1163: $line14.$read$$iw$$iw$$iw$$iw$Foo\n// +- *FileScan parquet [i#1131L,j#1132] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [], ReadSchema: struct\n\nAs we see from the explained Physical Plan, Spark was not able to optimize our query as before.\nReading the parquet file will required loading all the fields of Foo. This might be ok for\nsmall datasets or for datasets with few columns, but will be extremely slow for most practical\napplications.\nIntuitively, Spark currently doesn't have a way to look inside the code we pass in these two\nclosures. It only knows that they both take one argument of type Foo, but it has no way of knowing if\nwe use just one or all of Foo's fields.\nThe TypedDataset in frameless solves this problem. It allows for a simple and type-safe syntax\nwith a fully optimized query plan.\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport frameless.syntax._\n// import frameless.syntax._\n\nval fds = TypedDataset.create(ds)\n// fds: frameless.TypedDataset[Foo] = [i: bigint, j: string]\n\nfds.filter( fds('i) === 10 ).select( fds('i) ).show().run()\n// +---+\n// | _1|\n// +---+\n// | 10|\n// +---+\n//\n\nAnd the optimized Physical Plan:\nfds.filter( fds('i) === 10 ).select( fds('i) ).explain()\n// == Physical Plan ==\n// *Project [i#1131L AS _1#1236L]\n// +- *Filter (isnotnull(i#1131L) && (i#1131L = 10))\n// +- *FileScan parquet [i#1131L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nAnd the compiler is our friend.\nscala> fds.filter( fds('i) === 10 ).select( fds('x) )\n:24: error: No column Symbol with shapeless.tag.Tagged[String(\"x\")] of type A in Foo\n fds.filter( fds('i) === 10 ).select( fds('x) )\n ^\n\nDifferences in Encoders\nEncoders in Spark's Datasets are partially type-safe. If you try to create a Dataset using a type that is not \n a Scala Product then you get a compilation error:\nclass Bar(i: Int)\n// defined class Bar\n\nBar is neither a case class nor a Product, so the following correctly gives a compilation error in Spark:\nscala> spark.createDataset(Seq(new Bar(1)))\n:24: error: Unable to find encoder for type stored in a Dataset. Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._ Support for serializing other types will be added in future releases.\n spark.createDataset(Seq(new Bar(1)))\n ^\n\nHowever, the compile type guards implemented in Spark are not sufficient to detect non encodable members. \nFor example, using the following case class leads to a runtime failure:\ncase class MyDate(jday: java.util.Date)\n// defined class MyDate\n\nval myDateDs = spark.createDataset(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// java.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n// - field (class: \"java.util.Date\", name: \"jday\")\n// - root class: \"MyDate\"\n// at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:625)\n// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$10.apply(ScalaReflection.scala:619)\n// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$10.apply(ScalaReflection.scala:607)\n// at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n// at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n// at scala.collection.immutable.List.foreach(List.scala:392)\n// at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n// at scala.collection.immutable.List.flatMap(List.scala:355)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:607)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:438)\n// at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:71)\n// at org.apache.spark.sql.Encoders$.product(Encoders.scala:275)\n// at org.apache.spark.sql.LowPrioritySQLImplicits$class.newProductEncoder(SQLImplicits.scala:233)\n// at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:33)\n// ... 778 elided\n\nIn comparison, a TypedDataset will notify about the encoding problem at compile time: \nTypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// :25: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[MyDate]\n// TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// ^\n\n"},"TypedEncoder.html":{"url":"TypedEncoder.html","title":"Typed Encoders in Frameless","keywords":"","body":"Typed Encoders in Frameless\nSpark uses Reflection to derive it's Encoders, which is why they can fail at run time. For example, because Spark does not supports java.util.Date, the following leads to an error:\nimport org.apache.spark.sql.Dataset\nimport spark.implicits._\n\ncase class DateRange(s: java.util.Date, e: java.util.Date)\n\nscala> val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))\njava.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n- field (class: \"java.util.Date\", name: \"s\")\n- root class: \"DateRange\"\n at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:625)\n at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$10.apply(ScalaReflection.scala:619)\n at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$10.apply(ScalaReflection.scala:607)\n at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n at scala.collection.immutable.List.foreach(List.scala:392)\n at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n at scala.collection.immutable.List.flatMap(List.scala:355)\n at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:607)\n at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:438)\n at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:71)\n at org.apache.spark.sql.Encoders$.product(Encoders.scala:275)\n at org.apache.spark.sql.LowPrioritySQLImplicits$class.newProductEncoder(SQLImplicits.scala:233)\n at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:33)\n ... 242 elided\n\nAs shown by the stack trace, this runtime error goes thought ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection based approach is it's inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.\nFrameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the code java.util.Date example won't compile with frameless:\nimport frameless.TypedDataset\nimport frameless.syntax._\n\nval ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// :29: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]\n// val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// ^\n\nType class derivation takes care of recursively constructing (and proving the existence of) TypeEncoders for case classes. The following works as expected:\ncase class Bar(d: Double, s: String)\n// defined class Bar\n\ncase class Foo(i: Int, b: Bar)\n// defined class Foo\n\nval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, \"s\"))))\n// ds: frameless.TypedDataset[Foo] = [i: int, b: struct]\n\nds.collect()\n// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@208e2282\n\nBut any non-encodable in the case class hierarchy will be detected at compile time:\ncase class BarDate(d: Double, s: String, t: java.util.Date)\ncase class FooDate(i: Int, b: BarDate)\n\nval ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// :31: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]\n// val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// ^\n\nIt should be noted that once derived, reflection based Encoders and implicitly derived TypeEncoders have identical performances. The derivation mechanism is different, but the objects generated to encode and decode JVM object in the Spark internal representation behave the same at run-time.\n"},"Injection.html":{"url":"Injection.html","title":"Injection: Creating Custom Encoders","keywords":"","body":"Injection: Creating Custom Encoders\nInjection lets us define encoders for types that do not have one by injecting A into an encodable type B.\nThis is the definition of the injection typeclass:\ntrait Injection[A, B] extends Serializable {\n def apply(a: A): B\n def invert(b: B): A\n}\n\nExample\nLet's define a simple case class:\ncase class Person(age: Int, birthday: java.util.Date)\n// defined class Person\n\nval people = Seq(Person(42, new java.util.Date))\n// people: Seq[Person] = List(Person(42,Wed Oct 18 09:21:38 PDT 2017))\n\nAnd an instance of a TypedDataset:\nval personDS = TypedDataset.create(people)\n// :24: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n// val personDS = TypedDataset.create(people)\n// ^\n\nLooks like we can't, a TypedEncoder instance of Person is not available, or more precisely for java.util.Date.\nBut we can define a injection from java.util.Date to an encodable type, like Long:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = new Injection[java.util.Date, Long] {\n def apply(d: java.util.Date): Long = d.getTime()\n def invert(l: Long): java.util.Date = new java.util.Date(l)\n}\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@2b4ee43e\n\nWe can be less verbose using the Injection.apply function:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@5a548922\n\nNow we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, birthday: bigint]\n\nAnother example\nLet's define a sealed family:\nsealed trait Gender\n// defined trait Gender\n\ncase object Male extends Gender\n// defined object Male\n\ncase object Female extends Gender\n// defined object Female\n\ncase object Other extends Gender\n// defined object Other\n\nAnd a simple case class:\ncase class Person(age: Int, gender: Gender)\n// defined class Person\n\nval people = Seq(Person(42, Male))\n// people: Seq[Person] = List(Person(42,Male))\n\nAgain if we try to create a TypedDataset, we get a compilation error.\nval personDS = TypedDataset.create(people)\n// :32: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n// val personDS = TypedDataset.create(people)\n// ^\n\nLet's define an injection instance for Gender:\nimplicit val genderToInt: Injection[Gender, Int] = Injection(\n {\n case Male => 1\n case Female => 2\n case Other => 3\n },\n {\n case 1 => Male\n case 2 => Female\n case 3 => Other\n })\n// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@62c73008\n\nAnd now we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, gender: int]\n\n"},"Job.html":{"url":"Job.html","title":"Job[A]","keywords":"","body":"Job[A]\nAll operations on TypedDataset are lazy. An operation either returns a new\ntransformed TypedDataset or an F[A], where F[_] is a type constructor\nwith an instance of the SparkDelay typeclass and A is the result of running a\nnon-lazy computation in Spark. \nA default such type constructor called Job is provided by Frameless. \nJob serves several functions:\n\nMakes all operations on a TypedDataset lazy, which makes them more predictable compared to having\nfew operations being lazy and other being strict\nAllows the programmer to make expensive blocking operations explicit\nAllows for Spark jobs to be lazily sequenced using monadic composition via for-comprehension\nProvides an obvious place where you can annotate/name your Spark jobs to make it easier\nto track different parts of your application in the Spark UI\n\nThe toy example showcases the use of for-comprehension to explicitly sequences Spark Jobs.\nFirst we calculate the size of the TypedDataset and then we collect to the driver\nexactly 20% of its elements:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval ds = TypedDataset.create(1 to 20)\n// ds: frameless.TypedDataset[Int] = [_1: int]\n\nval countAndTakeJob =\n for {\n count \nThe countAndTakeJob can either be executed using run() (as we show above) or it can\nbe passed along to other parts of the program to be further composed into more complex sequences\nof Spark jobs.\nimport frameless.Job\n// import frameless.Job\n\ndef computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min)\n// computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]\n\nval finalJob = computeMinOfSample(countAndTakeJob)\n// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@6ef768bf\n\nNow we can execute this new job by specifying a group-id and a description.\nThis allows the programmer to see this information on the Spark UI and help track, say,\nperformance issues.\nfinalJob.\n withGroupId(\"samplingJob\").\n withDescription(\"Samples 20% of elements and computes the min\").\n run()\n// res2: Int = 1\n\nMore on SparkDelay\nAs mentioned above, SparkDelay[F[_]] is a typeclass required for suspending\neffects by Spark computations. This typeclass represents the ability to suspend\nan => A thunk into an F[A] value, while implicitly capturing a SparkSession.\nAs it is a typeclass, it is open for implementation by the user in order to use\nother data types for suspension of effects. The cats module, for example, uses\nthis typeclass to support suspending Spark computations in any effect type that\nhas a cats.effect.Sync instance.\n"},"Cats.html":{"url":"Cats.html","title":"Using Cats with RDDs","keywords":"","body":"Using Cats with Frameless\nThere are two main parts to the cats integration offered by frameless:\n\neffect suspension in TypedDataset using cats-effect and cats-mtl\nRDD enhancements using algebraic typeclasses in cats-kernel\n\nAll the examples below assume you have previously imported cats.implicits and frameless.cats.implicits.\nNote that you should not import frameless.syntax._ together with frameless.cats.implicits._.\nimport cats.implicits._\n// import cats.implicits._\n\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nEffect Suspension in typed datasets\nAs noted in the section about Job, all operations on TypedDataset are lazy. The results of \noperations that would normally block on plain Spark APIs are wrapped in a type constructor F[_], \nfor which there exists an instance of SparkDelay[F]. This typeclass represents the operation of \ndelaying a computation and capturing an implicit SparkSession. \nIn the cats module, we utilize the typeclasses from cats-effect for abstracting over these \neffect types - namely, we provide an implicit SparkDelay instance for all F[_] for which exists\nan instance of cats.effect.Sync[F].\nThis allows one to run operations on TypedDataset in an existing monad stack. For example, given\nthis pre-existing monad stack:\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport cats.data.ReaderT\n// import cats.data.ReaderT\n\nimport cats.effect.IO\n// import cats.effect.IO\n\nimport cats.effect.implicits._\n// import cats.effect.implicits._\n\ntype Action[T] = ReaderT[IO, SparkSession, T]\n// defined type alias Action\n\nWe will be able to request that values from TypedDataset will be suspended in this stack:\nval typedDs = TypedDataset.create(Seq((1, \"string\"), (2, \"another\")))\n// typedDs: frameless.TypedDataset[(Int, String)] = [_1: int, _2: string]\n\nval result: Action[(Seq[(Int, String)], Long)] = for {\n sample )\n\nAs with Job, note that nothing has been run yet. The effect has been properly suspended. To\nrun our program, we must first supply the SparkSession to the ReaderT layer and then\nrun the IO effect:\nresult.run(spark).unsafeRunSync()\n// res5: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)\n\nConvenience methods for modifying Spark thread-local variables\nThe frameless.cats.implicits._ import also provides some syntax enrichments for any monad\nstack that has the same capabilities as Action above. Namely, the ability to provide an\ninstance of SparkSession and the ability to suspend effects.\nFor these to work, we will need to import the implicit machinery from the cats-mtl library:\nimport cats.mtl.implicits._\n// import cats.mtl.implicits._\n\nAnd now, we can set the description for the computation being run:\nval resultWithDescription: Action[(Seq[(Int, String)], Long)] = for {\n r )\n\nresultWithDescription.run(spark).unsafeRunSync()\n// Description: fancy cats\n// res6: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)\n\nUsing algebraic typeclasses from Cats with RDDs\nData aggregation is one of the most important operations when working with Spark (and data in general).\nFor example, we often have to compute the min, max, avg, etc. from a set of columns grouped by\ndifferent predicates. This section shows how cats simplifies these tasks in Spark by\nleveraging a large collection of Type Classes for ordering and aggregating data.\nCats offers ways to sort and aggregate tuples of arbitrary arity.\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nval data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[14] at makeRDD at :45\n\nprintln(data.csum)\n// (10,9,9)\n\nprintln(data.cmax)\n// (8,2,3)\n\nprintln(data.cmin)\n// (1,2,3)\n\nThe following example aggregates all the elements with a common key.\ntype User = String\n// defined type alias User\n\ntype TransactionCount = Int\n// defined type alias TransactionCount\n\nval allData: RDD[(User,TransactionCount)] =\n sc.makeRDD((\"Bob\", 12) :: (\"Joe\", 1) :: (\"Anna\", 100) :: (\"Bob\", 20) :: (\"Joe\", 2) :: Nil)\n// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[15] at makeRDD at :48\n\nval totalPerUser = allData.csumByKey\n// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[16] at reduceByKey at implicits.scala:18\n\ntotalPerUser.collectAsMap\n// res10: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)\n\nThe same example would work for more complex keys.\nval allDataComplexKeu =\n sc.makeRDD( (\"Bob\", Map(\"task1\" -> 10)) ::\n (\"Joe\", Map(\"task1\" -> 1, \"task2\" -> 3)) :: (\"Bob\", Map(\"task1\" -> 10, \"task2\" -> 1)) :: (\"Joe\", Map(\"task3\" -> 4)) :: Nil )\n// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ParallelCollectionRDD[17] at makeRDD at :46\n\nval overalTasksPerUser = allDataComplexKeu.csumByKey\n// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ShuffledRDD[18] at reduceByKey at implicits.scala:18\n\noveralTasksPerUser.collectAsMap\n// res11: scala.collection.Map[String,scala.collection.immutable.Map[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))\n\nJoins\n// Type aliases for meaningful types\ntype TimeSeries = Map[Int,Int]\n// defined type alias TimeSeries\n\ntype UserName = String\n// defined type alias UserName\n\nExample: Using the implicit full-our-join operator\nimport frameless.cats.outer._\n// import frameless.cats.outer._\n\nval day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 2, 1 -> 4)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Sam\", Map(0 -> 1)) :: Nil )\n// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[19] at makeRDD at :50\n\nval day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 10, 1 -> 11)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Joe\", Map(0 -> 1, 1 -> 2)) :: Nil )\n// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[20] at makeRDD at :50\n\nval daysCombined = day1 |+| day2\n// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[24] at mapValues at implicits.scala:43\n\ndaysCombined.collect()\n// res13: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))\n\nNote how the user's timeseries from different days have been aggregated together.\nThe |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join\non the key and combine values using the default Semigroup for the value type.\nIn cats:\nMap(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)\n// res14: Map[Int,Int] = Map(1 -> 6, 2 -> 2)\n\n"},"TypedML.html":{"url":"TypedML.html","title":"Using Spark ML with TypedDataset","keywords":"","body":"TypedDataset support for Spark ML\nThe goal of the frameless-ml module is to be able to use Spark ML with TypedDataset and\nto eventually provide a more strongly typed ML API for Spark. Currently, this module is at its very beginning and only \nprovides TypedEncoder instances for Spark ML's linear algebra data types.\nUsing Vector and Matrix with TypedDataset\nframeless-ml provides TypedEncoder instances for org.apache.spark.ml.linalg.Vector \nand org.apache.spark.ml.linalg.Matrix:\nimport frameless.ml._\n// import frameless.ml._\n\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport org.apache.spark.ml.linalg._\n// import org.apache.spark.ml.linalg._\n\nval vector = Vectors.dense(1, 2, 3)\n// vector: org.apache.spark.ml.linalg.Vector = [1.0,2.0,3.0]\n\nval vectorDs = TypedDataset.create(Seq(\"label\" -> vector))\n// vectorDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Vector)] = [_1: string, _2: vector]\n\nval matrix = Matrices.dense(2, 1, Array(1, 2))\n// matrix: org.apache.spark.ml.linalg.Matrix =\n// 1.0\n// 2.0\n\nval matrixDs = TypedDataset.create(Seq(\"label\" -> matrix))\n// matrixDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Matrix)] = [_1: string, _2: matrix]\n\nUnder the hood, Vector and Matrix are encoded using org.apache.spark.ml.linalg.VectorUDT \nand org.apache.spark.ml.linalg.MatrixUDT. This is possible thanks to the implicit derivation \nfrom org.apache.spark.sql.types.UserDefinedType[A] to TypedEncoder[A] defined in TypedEncoder companion object.\n"},"TypedDataFrame.html":{"url":"TypedDataFrame.html","title":"Proof of Concept: TypedDataFrame","keywords":"","body":"Proof of Concept: TypedDataFrame\nTypedDataFrame is the API developed in the early stages of frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future developments of frameless. However, the design is interesting enough for being documented.\nTo safely manipulate DataFrames we use a technique called shadow type, which consists in storing additional information about a value in a \"dummy\" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.\nDiving in\nIn TypedDataFrame, we use a single Schema to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:\nimport org.apache.spark.sql.DataFrame\nimport shapeless.HList\n\nclass TDataFrame[Schema Boolean): TDataFrame[Schema] = ???\n\n def select[C \nAs you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.\nType-level column referencing\nFor Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching column referencing at compile type. When everything goes well, frameless select is very similar to vanilla select, except that it keeps track of the selected column types:\nimport frameless.TypedDataFrame\n\ncase class Foo(s: String, d: Double, i: Int)\n\ndef selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n tf.select('i, 's)\n\nHowever, in case of typo, it gets coughs right away:\ndef selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n tf.select('j, 's)\n\nType-level joins\nJoins can available with two different syntaxes, the first lets you reference different columns on each TypedDataFrame, and ensures that their all exists and have compatible types:\ncase class Bar(i: Int, j: String, b: Boolean)\n\ndef join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =\n tf1.innerJoin(tf2).on('s).and('j)\n\nThe second syntax bring some convenience when the joining columns have identical names in both tables:\ndef join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n : TypedDataFrame[(String, Double, Int, String, Boolean)] =\n tf1.innerJoin(tf2).using('i)\n\nFurther example are available in the TypedDataFrame join tests.\nComplete example\nWe now consider a complete example to see how the type system can frameless can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city map and neighborhood:\ntype Neighborhood = String\ntype Address = String\n\ncase class PhoneBookEntry(\n address: Address,\n residents: String,\n phoneNumber: Double\n)\n\ncase class CityMapEntry(\n address: Address,\n neighborhood: Neighborhood\n)\n\nOur goal will be to compute the neighborhood with unique names, approximating \"unique\" with names containing less common\nletters in the alphabet: 'x', 'q', and 'z'. We are going to need a natural language processing library at some point, so\nlet's use the following for the example:\nobject NLPLib {\n def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))\n}\n\nSuppose we manage to obtain a TypedDataFrame[PhoneBookEntry] and a TypedDataFrame[CityMapEntry] public data, here is what our Spark job could look like with frameless:\nimport org.apache.spark.sql.SQLContext\n\n// These case classes are used to hold intermediate results\ncase class Family(residents: String, neighborhood: Neighborhood)\ncase class Person(name: String, neighborhood: Neighborhood)\ncase class NeighborhoodCount(neighborhood: Neighborhood, count: Long)\n\ndef bestNeighborhood\n (phoneBookTF: TypedDataFrame[PhoneBookEntry], cityMapTF: TypedDataFrame[CityMapEntry])\n (implicit c: SQLContext): String = {\n (((((((((\n phoneBookTF\n .innerJoin(cityMapTF).using('address) :TypedDataFrame[(Address, String, Double, String)])\n .select('_2, '_4) :TypedDataFrame[(String, String)])\n .as[Family]() :TypedDataFrame[Family])\n .flatMap { f =>\n f.residents.split(' ').map(r => Person(r, f.neighborhood))\n } :TypedDataFrame[Person])\n .filter { p =>\n NLPLib.uniqueName(p.name)\n } :TypedDataFrame[Person])\n .groupBy('neighborhood).count() :TypedDataFrame[(String, Long)])\n .as[NeighborhoodCount]() :TypedDataFrame[NeighborhoodCount])\n .sortDesc('count) :TypedDataFrame[NeighborhoodCount])\n .select('neighborhood) :TypedDataFrame[Tuple1[String]])\n .head._1\n}\n\nIf you compare this version from Spark vanilla where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.\nLimitations\nThe main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.\nIn the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.\n"}}} \ No newline at end of file From 3af8b2df08a1ed0db67cb70286d43b1ceb0264d8 Mon Sep 17 00:00:00 2001 From: imarios Date: Sun, 18 Feb 2018 15:22:40 -0800 Subject: [PATCH 004/220] Updated docs for 0.5.0 release --- Cats.html | 63 +++-- FeatureOverview.html | 396 +++++++++++++++++++++++++++----- Injection.html | 14 +- Job.html | 6 +- TypedDataFrame.html | 22 +- TypedDatasetVsSparkDataset.html | 149 +++++++++--- TypedEncoder.html | 37 +-- TypedML.html | 299 ++++++++++++++++++++++-- docs/src/main/tut/README.md | 78 +++++-- index.html | 85 +++++-- search_index.json | 2 +- 11 files changed, 928 insertions(+), 223 deletions(-) diff --git a/Cats.html b/Cats.html index 1eb001cbb..c720e21b5 100644 --- a/Cats.html +++ b/Cats.html @@ -252,7 +252,7 @@

                Using Cats with Frameless

                -

                There are two main parts to the cats integration offered by frameless:

                +

                There are two main parts to the cats integration offered by Frameless:

                • effect suspension in TypedDataset using cats-effect and cats-mtl
                • RDD enhancements using algebraic typeclasses in cats-kernel
                  • @@ -318,7 +318,7 @@

                  Convenie 
                  val resultWithDescription: Action[(Seq[(Int, String)], Long)] = for {
   r <- result.withDescription("fancy cats")
   session <- ReaderT.ask[IO, SparkSession]
-  _ <- ReaderT.lift {
+  _ <- ReaderT.liftF {
          IO {
            println(s"Description: ${session.sparkContext.getLocalProperty("spark.job.description")}")
          }
@@ -340,7 +340,7 @@ 
                  Using algebraic typecla
 // import frameless.cats.implicits._
 
 val data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)
-// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[14] at makeRDD at <console>:45
+// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[14] at makeRDD at <console>:44
 
 println(data.csum)
 // (10,9,9)
@@ -351,6 +351,30 @@ 
                  Using algebraic typecla
 println(data.cmin)
 // (1,2,3)
                  +

                  In case the RDD is empty, the csum, cmax and cmin will use the default values for the type of +elements inside the RDD. There are counterpart operations to those that have an Option return type +to deal with the case of an empty RDD:

                  +
                  val data: RDD[(Int, Int, Int)] = sc.emptyRDD
+// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = EmptyRDD[15] at emptyRDD at <console>:44
+
+println(data.csum)
+// (0,0,0)
+
+println(data.csumOption)
+// None
+
+println(data.cmax)
+// (0,0,0)
+
+println(data.cmaxOption)
+// None
+
+println(data.cmin)
+// (0,0,0)
+
+println(data.cminOption)
+// None
+

                  The following example aggregates all the elements with a common key.

                  type User = String
 // defined type alias User
@@ -360,25 +384,28 @@ 
                  Using algebraic typecla
 
 val allData: RDD[(User,TransactionCount)] =
    sc.makeRDD(("Bob", 12) :: ("Joe", 1) :: ("Anna", 100) :: ("Bob", 20) :: ("Joe", 2) :: Nil)
-// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[15] at makeRDD at <console>:48
+// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[16] at makeRDD at <console>:47
 
 val totalPerUser =  allData.csumByKey
-// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[16] at reduceByKey at implicits.scala:18
+// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[17] at reduceByKey at implicits.scala:42
 
 totalPerUser.collectAsMap
-// res10: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)
+// res16: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)

                  The same example would work for more complex keys.

                  -
                  val allDataComplexKeu =
-   sc.makeRDD( ("Bob", Map("task1" -> 10)) ::
-    ("Joe", Map("task1" -> 1, "task2" -> 3)) :: ("Bob", Map("task1" -> 10, "task2" -> 1)) :: ("Joe", Map("task3" -> 4)) :: Nil )
-// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ParallelCollectionRDD[17] at makeRDD at <console>:46
+
                  import scala.collection.immutable.SortedMap
+// import scala.collection.immutable.SortedMap
+
+val allDataComplexKeu =
+   sc.makeRDD( ("Bob", SortedMap("task1" -> 10)) ::
+    ("Joe", SortedMap("task1" -> 1, "task2" -> 3)) :: ("Bob", SortedMap("task1" -> 10, "task2" -> 1)) :: ("Joe", SortedMap("task3" -> 4)) :: Nil )
+// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ParallelCollectionRDD[18] at makeRDD at <console>:46
 
 val overalTasksPerUser = allDataComplexKeu.csumByKey
-// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ShuffledRDD[18] at reduceByKey at implicits.scala:18
+// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ShuffledRDD[19] at reduceByKey at implicits.scala:42
 
 overalTasksPerUser.collectAsMap
-// res11: scala.collection.Map[String,scala.collection.immutable.Map[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))
+// res17: scala.collection.Map[String,scala.collection.immutable.SortedMap[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))
 
                  
 
                  Joins
                  
 
                  // Type aliases for meaningful types
@@ -393,23 +420,23 @@ 
                  Joins
                  
 // import frameless.cats.outer._
 
 val day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 2, 1 -> 4)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Sam", Map(0 -> 1)) :: Nil )
-// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[19] at makeRDD at <console>:50
+// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[20] at makeRDD at <console>:50
 
 val day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 10, 1 -> 11)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Joe", Map(0 -> 1, 1 -> 2)) :: Nil )
-// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[20] at makeRDD at <console>:50
+// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[21] at makeRDD at <console>:50
 
 val daysCombined = day1 |+| day2
-// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[24] at mapValues at implicits.scala:43
+// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[25] at mapValues at implicits.scala:67
 
 daysCombined.collect()
-// res13: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))
+// res19: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))
 
                  
 
                  Note how the user's timeseries from different days have been aggregated together.
 The |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join
 on the key and combine values using the default Semigroup for the value type.
                  
 
                  In cats:
                  
 
                  Map(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)
-// res14: Map[Int,Int] = Map(1 -> 6, 2 -> 2)
+// res20: Map[Int,Int] = Map(1 -> 6, 2 -> 2)
 
                  
 
                                 
@@ -454,7 +481,7 @@ 
                  No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"next":{"title":"Using Spark ML with TypedDataset","level":"1.8","depth":1,"path":"TypedML.md","ref":"TypedML.md","articles":[]},"previous":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Cats.md","mtime":"2017-10-18T16:21:18.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-10-18T16:22:33.699Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"next":{"title":"Using Spark ML with TypedDataset","level":"1.8","depth":1,"path":"TypedML.md","ref":"TypedML.md","articles":[]},"previous":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Cats.md","mtime":"2018-02-18T23:18:30.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/FeatureOverview.html b/FeatureOverview.html
index 872ffe30e..7935590b2 100644
--- a/FeatureOverview.html
+++ b/FeatureOverview.html
@@ -259,9 +259,8 @@ 
                  TypedDataset: Feature Overview
                  
 import frameless.functions.aggregate._
 import frameless.TypedDataset
 
-val conf = new SparkConf().setMaster("local[*]").setAppName("frameless repl").set("spark.ui.enabled", "false")
-val spark = SparkSession.builder().config(conf).appName("REPL").getOrCreate()
-implicit val sqlContext = spark.sqlContext
+val conf = new SparkConf().setMaster("local[*]").setAppName("Frameless repl").set("spark.ui.enabled", "false")
+implicit val spark = SparkSession.builder().config(conf).appName("REPL").getOrCreate()
 spark.sparkContext.setLogLevel("WARN")
 
 import spark.implicits._
@@ -305,11 +304,11 @@ 
                  Typesafe column referencing

                  This is completely type-safe, for instance suppose we misspell city as citi:

                  aptTypedDs.select(aptTypedDs('citi))
-// <console>:28: error: No column Symbol with shapeless.tag.Tagged[String("citi")] of type A in Apartment
+// <console>:27: error: No column Symbol with shapeless.tag.Tagged[String("citi")] of type A in Apartment
 //        aptTypedDs.select(aptTypedDs('citi))
 //                                    ^
                  -

                  This gets raised at compile-time, whereas with the standard Dataset API the error appears at run-time (enjoy the stack trace):

                  +

                  This gets raised at compile time, whereas with the standard Dataset API the error appears at runtime (enjoy the stack trace):

                  aptDs.select('citi)
 // org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [city, surface, price, bedrooms];;
 // 'Project ['citi]
@@ -344,10 +343,10 @@ 
                  Typesafe column referencing
                  
 //   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)
 //   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)
 //   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)
-//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:66)
-//   at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2872)
-//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1153)
-//   ... 434 elided
+//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:67)
+//   at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2884)
+//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1150)
+//   ... 430 elided

                  select() supports arbitrary column operations:

                  aptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()
@@ -363,56 +362,44 @@ 
                  Typesafe column referencing
                  
 // +----+---+
 //
                  -

                  Note that unlike the standard Spark API where some operations are lazy and some are not, TypedDatasets have all operations to be lazy. +

                  Note that unlike the standard Spark API, where some operations are lazy and some are not, all TypedDatasets operations are lazy. In the above example, show() is lazy. It requires to apply run() for the show job to materialize. A more detailed explanation of Job is given here.

                  Next we compute the price by surface unit:

                  val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))
-// <console>:27: error: overloaded method value / with alternatives:
+// <console>:26: error: overloaded method value / with alternatives:
 //   (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] <and>
-//   [Out](other: frameless.TypedColumn[Apartment,Double])(implicit n: frameless.CatalystDivisible[Double,Out], implicit e: frameless.TypedEncoder[Out])frameless.TypedColumn[Apartment,Out]
+//   [Out, TT, W](other: frameless.TypedColumn[TT,Double])(implicit n: frameless.CatalystDivisible[Double,Out], implicit e: frameless.TypedEncoder[Out], implicit w: frameless.With[Apartment,TT]{type Out = W})frameless.TypedColumn[W,Out]
 //  cannot be applied to (frameless.TypedColumn[Apartment,Int])
 //        val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))
 //                                                                      ^
                  -

                  As the error suggests, we can't divide a TypedColumn of Double by Int. -For safety, in Frameless only math operations between same types is allowed. -There are two ways to proceed here:

                  -

                  (a) Explicitly cast Int to Double (manual)

                  +

                  As the error suggests, we can't divide a TypedColumn of Double by Int. +For safety, in Frameless only math operations between same types is allowed:

                  val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])
 // priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]
 
 priceBySurfaceUnit.collect().run()
 // res6: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)
                  -

                  (b) Perform the cast implicitly (automated)

                  -
                  import frameless.implicits.widen._
-// import frameless.implicits.widen._
-
-val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))
-// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]
-
-priceBySurfaceUnit.collect.run()
-// res7: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)
-

                  Looks like it worked, but that cast seems unsafe right? Actually it is safe. Let's try to cast a TypedColumn of String to Double:

                  aptTypedDs('city).cast[Double]
-// <console>:31: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]
+// <console>:27: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]
 //        aptTypedDs('city).cast[Double]
 //                              ^
                  -

                  The compile-time error tells us that to perform the cast, an evidence -(in the form of CatalystCast[String, Double]) must be available. -Since casting from String to Double is not allowed, this results -in a compilation error.

                  -

                  Check here +

                  The compile-time error tells us that to perform the cast, an evidence +(in the form of CatalystCast[String, Double]) must be available. +Since casting from String to Double is not allowed, this results +in a compilation error.

                  +

                  Check here for the set of available CatalystCast.

                  -

                  TypeSafe TypedDataset casting and projections

                  +

                  Casting and projections

                  With select() the resulting TypedDataset is of type TypedDataset[TupleN[...]] (with N in [1...10]). For example, if we select three columns with types String, Int, and Boolean the result will have type -TypedDataset[(String, Int, Boolean)]. To select more than ten columns use the selectMany() method. -Select has better IDE support than the macro based selectMany, so prefer select() for the general case.

                  +TypedDataset[(String, Int, Boolean)]. To select more than ten columns use the selectMany() method. +Select has better IDE support than the macro based selectMany, so prefer select() for the general case.

                  We often want to give more expressive types to the result of our computations. as[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long as the types in U and T align.

                  @@ -436,7 +423,7 @@

                  TypeSafe TypedDataset cas

                  Next we try to cast a (String, String) to an UpdatedSurface (which has types String, Int). The cast is not valid and the expression does not compile:

                  aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]
-// <console>:33: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]
+// <console>:29: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]
 //        aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]
 //                                                                  ^
                  @@ -445,16 +432,19 @@

                  Projections

                  Projections allows to easily select the fields we are interested while preserving their initial name and types for extra safety.

                  Here is an example using the TypedDataset[Apartment] with an additional column:

                  -
                  import frameless.implicits.widen._
-// import frameless.implicits.widen._
-
-val aptds = aptTypedDs // For shorter expressions
+
                  val aptds = aptTypedDs // For shorter expressions
 // aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
 
 case class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)
 // defined class ApartmentDetails
 
-val aptWithRatio = aptds.select(aptds('city), aptds('price), aptds('surface), aptds('price) / aptds('surface)).as[ApartmentDetails]
+val aptWithRatio =
+  aptds.select(
+    aptds('city),
+    aptds('price),
+    aptds('surface),
+    aptds('price) / aptds('surface).cast[Double]
+  ).as[ApartmentDetails]
 // aptWithRatio: frameless.TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]
 
                  
 
                  Suppose we only want to work with city and ratio:
                  
@@ -498,7 +488,7 @@ 
                  Projections
                  
 
                  case class PriceInfo2(ratio: Double, pricEE: Double)
 
                  
 
                  aptWithRatio.project[PriceInfo2]
-// <console>:36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?
+// <console>:29: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?
 //        aptWithRatio.project[PriceInfo2]
 //                            ^
 
                  
@@ -506,10 +496,256 @@ 
                  Projections
                  
 
                  case class PriceInfo3(ratio: Int, price: Double) // ratio should be Double
 
                  
 
                  aptWithRatio.project[PriceInfo3]
-// <console>:36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?
+// <console>:29: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?
 //        aptWithRatio.project[PriceInfo3]
 //                            ^
 
                  
+
                  Union of TypedDatasets
                  
+
                  Lets create a projection of our original dataset with a subset of the fields.
                  
+
                  case class ApartmentShortInfo(city: String, price: Double, bedrooms: Int)
+
+val aptTypedDs2: TypedDataset[ApartmentShortInfo] = aptTypedDs.project[ApartmentShortInfo]
+
                  
+
                  The union of aptTypedDs2 with aptTypedDs uses all the fields of the caller (aptTypedDs2)
+and expects the other dataset (aptTypedDs) to include all those fields. 
+If field names/types do not match you get a compilation error. 
                  
+
                  aptTypedDs2.union(aptTypedDs).show().run
+// +-----+--------+--------+
+// | city|   price|bedrooms|
+// +-----+--------+--------+
+// |Paris|300000.0|       2|
+// |Paris|450000.0|       3|
+// |Paris|250000.0|       1|
+// | Lyon|200000.0|       2|
+// | Lyon|133000.0|       1|
+// | Nice|325000.0|       3|
+// |Paris|300000.0|       2|
+// |Paris|450000.0|       3|
+// |Paris|250000.0|       1|
+// | Lyon|200000.0|       2|
+// | Lyon|133000.0|       1|
+// | Nice|325000.0|       3|
+// +-----+--------+--------+
+//
+
                  
+
                  The other way around will not compile, since aptTypedDs2 has only a subset of the fields. 
                  
+
                  aptTypedDs.union(aptTypedDs2).show().run
+// <console>:28: error: Cannot prove that ApartmentShortInfo can be projected to Apartment. Perhaps not all member names and types of Apartment are the same in ApartmentShortInfo?
+//        aptTypedDs.union(aptTypedDs2).show().run
+//                        ^
+
                  
+
                  Finally, as with project, union will align fields that have same names/types,
+so fields do not have to be in the same order. 
                  
+
                  TypedDataset functions and transformations
                  
+
                  Frameless supports many of Spark's functions and transformations. 
+However, whenever a Spark function does not exist in Frameless, 
+calling .dataset will expose the underlying 
+Dataset (from org.apache.spark.sql, the original Spark APIs), 
+where you can use anything that would be missing from the Frameless' API.
                  
+
                  These are the main imports for Frameless' aggregate and non-aggregate functions.
                  
+
                  import frameless.functions._                // For literals
+import frameless.functions.nonAggregate._   // e.g., concat, abs
+import frameless.functions.aggregate._      // e.g., count, sum, avg
+
                  
+
                  Drop/Replace/Add fields
                  
+
                  dropTupled() drops a single column and results in a tuple-based schema.
                  
+
                  aptTypedDs2.dropTupled('price): TypedDataset[(String,Int)]
+// res17: frameless.TypedDataset[(String, Int)] = [_1: string, _2: int]
+
                  
+
                  To drop a column and specify a new schema use drop().
                  
+
                  case class CityBeds(city: String, bedrooms: Int)
+// defined class CityBeds
+
+val cityBeds: TypedDataset[CityBeds] = aptTypedDs2.drop[CityBeds] 
+// cityBeds: frameless.TypedDataset[CityBeds] = [city: string, bedrooms: int]
+
                  
+
                  Often, you want to replace an existing column with a new value.
                  
+
                  val inflation = aptTypedDs2.withColumnReplaced('price, aptTypedDs2('price) * 2)
+// inflation: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]
+
+inflation.show(2).run()
+// +-----+--------+--------+
+// | city|   price|bedrooms|
+// +-----+--------+--------+
+// |Paris|600000.0|       2|
+// |Paris|900000.0|       3|
+// +-----+--------+--------+
+// only showing top 2 rows
+//
+
                  
+
                  Or use a literal instead.
                  
+
                  import frameless.functions.lit
+// import frameless.functions.lit
+
+aptTypedDs2.withColumnReplaced('price, lit(0.001)) 
+// res19: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]
+
                  
+
                  Adding a column using withColumnTupled() results in a tupled-based schema.
                  
+
                  aptTypedDs2.withColumnTupled(lit(Array("a","b","c"))).show(2).run()
+// +-----+--------+---+---------+
+// |   _1|      _2| _3|       _4|
+// +-----+--------+---+---------+
+// |Paris|300000.0|  2|[a, b, c]|
+// |Paris|450000.0|  3|[a, b, c]|
+// +-----+--------+---+---------+
+// only showing top 2 rows
+//
+
                  
+
                  Similarly, withColumn() adds a column and explicitly expects a schema for the result.
                  
+
                  case class CityBedsOther(city: String, bedrooms: Int, other: List[String])
+// defined class CityBedsOther
+
+cityBeds.
+   withColumn[CityBedsOther](lit(List("a","b","c"))).
+   show(1).run()
+// +-----+--------+---------+
+// | city|bedrooms|    other|
+// +-----+--------+---------+
+// |Paris|       2|[a, b, c]|
+// +-----+--------+---------+
+// only showing top 1 row
+//
+
                  
+
                  To conditionally change a column use the when/otherwise operation. 
                  
+
                  import frameless.functions.nonAggregate.when
+// import frameless.functions.nonAggregate.when
+
+aptTypedDs2.withColumnTupled(
+   when(aptTypedDs2('city) === "Paris", aptTypedDs2('price)).
+   when(aptTypedDs2('city) === "Lyon", lit(1.1)).
+   otherwise(lit(0.0))).show(8).run()
+// +-----+--------+---+--------+
+// |   _1|      _2| _3|      _4|
+// +-----+--------+---+--------+
+// |Paris|300000.0|  2|300000.0|
+// |Paris|450000.0|  3|450000.0|
+// |Paris|250000.0|  1|250000.0|
+// | Lyon|200000.0|  2|     1.1|
+// | Lyon|133000.0|  1|     1.1|
+// | Nice|325000.0|  3|     0.0|
+// +-----+--------+---+--------+
+//
+
                  
+
                  A simple way to add a column without loosing important schema information is
+to project the entire source schema into a single column using the asCol() method.
                  
+
                  val c = cityBeds.select(cityBeds.asCol, lit(List("a","b","c")))
+// c: frameless.TypedDataset[(CityBeds, List[String])] = [_1: struct<city: string, bedrooms: int>, _2: array<string>]
+
+c.show(1).run()
+// +---------+---------+
+// |       _1|       _2|
+// +---------+---------+
+// |[Paris,2]|[a, b, c]|
+// +---------+---------+
+// only showing top 1 row
+//
+
                  
+
                  asCol() is a new method, without a direct equivalent in Spark's Dataset or DataFrame APIs.
+When working with Spark's DataFrames, you often select all columns using .select($"*", ...). 
+In a way, asCol() is a typed equivalent of $"*". 
                  
+
                  Finally, note that using select() and asCol(), compared to using withColumn(), avoids the 
+need of an extra case class to define the result schema.
                  
+
                  To access nested columns, use the colMany() method. 
                  
+
                  c.select(c.colMany('_1, 'city), c('_2)).show(2).run()
+// +-----+---------+
+// |   _1|       _2|
+// +-----+---------+
+// |Paris|[a, b, c]|
+// |Paris|[a, b, c]|
+// +-----+---------+
+// only showing top 2 rows
+//
+
                  
+
                  Working with collections
                  
+
                  import frameless.functions._
+// import frameless.functions._
+
+import frameless.functions.nonAggregate._
+// import frameless.functions.nonAggregate._
+
                  
+
                  val t = cityRatio.select(cityRatio('city), lit(List("abc","c","d")))
+// t: frameless.TypedDataset[(String, List[String])] = [_1: string, _2: array<string>]
+
+t.withColumnTupled(
+   arrayContains(t('_2), "abc")
+).show(1).run()
+// +-----+-----------+----+
+// |   _1|         _2|  _3|
+// +-----+-----------+----+
+// |Paris|[abc, c, d]|true|
+// +-----+-----------+----+
+// only showing top 1 row
+//
+
                  
+
                  If accidentally you apply a collection function on a column that is not a collection,
+you get a compilation error.
                  
+
                  t.withColumnTupled(
+   arrayContains(t('_1), "abc")
+)
+// <console>:36: error: no type parameters for method arrayContains: (column: frameless.AbstractTypedColumn[T,C[A]], value: A)(implicit evidence$1: frameless.CatalystCollection[C])column.ThisType[T,Boolean] exist so that it can be applied to arguments (frameless.TypedColumn[(String, List[String]),String], String)
+//  --- because ---
+// argument expression's type is not compatible with formal parameter type;
+//  found   : frameless.TypedColumn[(String, List[String]),String]
+//  required: frameless.AbstractTypedColumn[?T,?C[?A]]
+// 
+//           arrayContains(t('_1), "abc")
+//           ^
+// <console>:36: error: type mismatch;
+//  found   : frameless.TypedColumn[(String, List[String]),String]
+//  required: frameless.AbstractTypedColumn[T,C[A]]
+//           arrayContains(t('_1), "abc")
+//                          ^
+// <console>:36: error: type mismatch;
+//  found   : String("abc")
+//  required: A
+//           arrayContains(t('_1), "abc")
+//                                 ^
+// <console>:36: error: Cannot do collection operations on columns of type C.
+//           arrayContains(t('_1), "abc")
+//                        ^
+
                  
+
                  Collecting data to the driver
                  
+
                  In Frameless all Spark actions (such as collect()) are safe.
                  
+
                  Take the first element from a dataset (if the dataset is empty return None).
                  
+
                  cityBeds.headOption.run()
+// res27: Option[CityBeds] = Some(CityBeds(Paris,2))
+
                  
+
                  Take the first n elements.
                  
+
                  cityBeds.take(2).run()
+// res28: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3))
+
                  
+
                  cityBeds.head(3).run()
+// res29: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1))
+
                  
+
                  cityBeds.limit(4).collect().run()
+// res30: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1), CityBeds(Lyon,2))
+
                  
+
                  Sorting columns
                  
+
                  Only column types that can be sorted are allowed to be selected for sorting. 
                  
+
                  aptTypedDs.orderBy(aptTypedDs('city).asc).show(2).run()
+// +----+-------+--------+--------+
+// |city|surface|   price|bedrooms|
+// +----+-------+--------+--------+
+// |Lyon|     83|200000.0|       2|
+// |Lyon|     45|133000.0|       1|
+// +----+-------+--------+--------+
+// only showing top 2 rows
+//
+
                  
+
                  The ordering can be changed by selecting .acs or .desc. 
                  
+
                  aptTypedDs.orderBy(
+   aptTypedDs('city).asc, 
+   aptTypedDs('price).desc
+).show(2).run()
+// +----+-------+--------+--------+
+// |city|surface|   price|bedrooms|
+// +----+-------+--------+--------+
+// |Lyon|     83|200000.0|       2|
+// |Lyon|     45|133000.0|       1|
+// +----+-------+--------+--------+
+// only showing top 2 rows
+//
+
                  
 
                  User Defined Functions
                  
 
                  Frameless supports lifting any Scala function (up to five arguments) to the
 context of a particular TypedDataset:
                  
@@ -546,11 +782,11 @@ 
                  GroupBy and Aggregations
                  
 // priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]
 
 priceByCity.collect().run()
-// res17: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))
+// res35: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))

                  Again if we try to aggregate a column that can't be aggregated, we get a compilation error

                  -
                  aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                        
-// <console>:34: error: Cannot compute average of type String.
+
                  aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))
+// <console>:35: error: Cannot compute average of type String.
 //        aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))
 //                                                     ^
 
                  
@@ -558,7 +794,7 @@ 
                  GroupBy and Aggregations
                  
 
                  val aptds = aptTypedDs // For shorter expressions
 // aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
 
-val cityPriceRatio =  aptds.select(aptds('city), aptds('price) / aptds('surface))
+val cityPriceRatio =  aptds.select(aptds('city), aptds('price) / aptds('surface).cast[Double])
 // cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]
 
 cityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()
@@ -571,13 +807,13 @@ 
                  GroupBy and Aggregations
                  
 // +-----+------------------+
 //
 
                  
-
                  We can also use pivot to further group data on a secondary column. 
-For example, we can compare the average price across cities by number of bedrooms.  
                  
+
                  We can also use pivot to further group data on a secondary column.
+For example, we can compare the average price across cities by number of bedrooms.
                  
 
                  case class BedroomStats(
-   city: String, 
+   city: String,
    AvgPriceBeds1: Option[Double], // Pivot values may be missing, so we encode them using Options
-   AvgPriceBeds2: Option[Double], 
-   AvgPriceBeds3: Option[Double], 
+   AvgPriceBeds2: Option[Double],
+   AvgPriceBeds3: Option[Double],
    AvgPriceBeds4: Option[Double])
 // defined class BedroomStats
 
@@ -599,30 +835,48 @@ 
                  GroupBy and Aggregations
                  
 // +-----+-------------+-------------+-------------+-------------+
 //
 
                  
-
                  With pivot, collecting data preserves typesafety by 
+
                  With pivot, collecting data preserves typesafety by
 encoding potentially missing columns with Option.
                  
 
                  bedroomStats.collect().run().foreach(println)
 // BedroomStats(Nice,None,None,Some(325000.0),None)
 // BedroomStats(Paris,Some(250000.0),Some(300000.0),Some(450000.0),None)
 // BedroomStats(Lyon,Some(133000.0),Some(200000.0),None,None)
 
                  
+
                  Working with Optional fields
                  
+
                  Optional fields can be converted to non-optional using getOrElse(). 
                  
+
                  val sampleStats = bedroomStats.select(
+   bedroomStats('AvgPriceBeds2).getOrElse(0.0),
+   bedroomStats('AvgPriceBeds3).getOrElse(0.0))
+// sampleStats: frameless.TypedDataset[(Double, Double)] = [_1: double, _2: double]
+
+sampleStats.show().run()   
+// +--------+--------+
+// |      _1|      _2|
+// +--------+--------+
+// |     0.0|325000.0|
+// |300000.0|450000.0|
+// |200000.0|     0.0|
+// +--------+--------+
+//
+
                  
 
                  Entire TypedDataset Aggregation
                  
 
                  We often want to aggregate the entire TypedDataset and skip the groupBy() clause.
-In Frameless you can do this using the agg() operator directly on the TypedDataset. 
-In the following example, we compute the average price, the average surface,
                  the minimum surface, and the set of cities for the entire dataset. 
                  
+In Frameless you can do this using the agg() operator directly on the TypedDataset.
+In the following example, we compute the average price, the average surface,
+the minimum surface, and the set of cities for the entire dataset.
                  
 
                  case class Stats(
-   avgPrice: Double, 
-   avgSurface: Double, 
-   minSurface: Int, 
+   avgPrice: Double,
+   avgSurface: Double,
+   minSurface: Int,
    allCities: Vector[String])
 // defined class Stats
 
 aptds.agg(
-   avg(aptds('price)), 
+   avg(aptds('price)),
    avg(aptds('surface)),
    min(aptds('surface)),
    collectSet(aptds('city))
-).as[Stats].show().run() 
+).as[Stats].show().run()
 // +-----------------+------------------+----------+-------------------+
 // |         avgPrice|        avgSurface|minSurface|          allCities|
 // +-----------------+------------------+----------+-------------------+
@@ -630,6 +884,22 @@ 
                  Entire TypedDataset Aggregation
                  
 // +-----------------+------------------+----------+-------------------+
 //
 
                  
+
                  You may apply any TypedColumn operation to a TypedAggregate column as well.
                  
+
                  import frameless.functions._
+// import frameless.functions._
+
+aptds.agg(
+   avg(aptds('price)) * min(aptds('surface)).cast[Double], 
+   avg(aptds('surface)) * 0.2,
+   litAggr("Hello World")
+).show().run()
+// +-----------------+------------------+-----------+
+// |               _1|                _2|         _3|
+// +-----------------+------------------+-----------+
+// |6908333.333333333|12.566666666666668|Hello World|
+// +-----------------+------------------+-----------+
+//
+
                  
 
                  Joins
                  
 
                  case class CityPopulationInfo(name: String, population: Int)
 
@@ -641,8 +911,8 @@ 
                  Joins
                  
 
 val citiInfoTypedDS = TypedDataset.create(cityInfo)
 
                  
-
                  Here is how to join the population information to the apartment's dataset.
                  
-
                  val withCityInfo = aptTypedDs.join(citiInfoTypedDS, aptTypedDs('city), citiInfoTypedDS('name))
+
                  Here is how to join the population information to the apartment's dataset:
                  
+
                  val withCityInfo = aptTypedDs.joinInner(citiInfoTypedDS) { aptTypedDs('city) === citiInfoTypedDS('name) }
 // withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct<city: string, surface: int ... 2 more fields>, _2: struct<name: string, population: int>]
 
 withCityInfo.show().run()
@@ -721,7 +991,7 @@ 
                  No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"next":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"previous":{"title":"Introduction","level":"1.1","depth":1,"path":"README.md","ref":"README.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"FeatureOverview.md","mtime":"2017-10-18T16:21:37.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-10-18T16:22:33.699Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"next":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"previous":{"title":"Introduction","level":"1.1","depth":1,"path":"README.md","ref":"README.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"FeatureOverview.md","mtime":"2018-02-18T23:18:57.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/Injection.html b/Injection.html
index b9ab9dfaf..54d695aa3 100644
--- a/Injection.html
+++ b/Injection.html
@@ -265,11 +265,11 @@ 
                  Example
                  
 // defined class Person
 
 val people = Seq(Person(42, new java.util.Date))
-// people: Seq[Person] = List(Person(42,Wed Oct 18 09:21:38 PDT 2017))
+// people: Seq[Person] = List(Person(42,Sun Feb 18 15:18:58 PST 2018))
 
                  
 
                  And an instance of a TypedDataset:
                  
 
                  val personDS = TypedDataset.create(people)
-// <console>:24: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]
+// <console>:23: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]
 //        val personDS = TypedDataset.create(people)
 //                                          ^
 
                  
@@ -282,14 +282,14 @@ 
                  Example
                  
   def apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@2b4ee43e
+// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@37f23430
 
                  
 
                  We can be less verbose using the Injection.apply function:
                  
 
                  import frameless._
 // import frameless._
 
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@5a548922
+// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@6cd20faa
 
                  
 
                  Now we can create our TypedDataset:
                  
 
                  val personDS = TypedDataset.create(people)
@@ -318,7 +318,7 @@ 
                  Another example
                  
 
                  
 
                  Again if we try to create a TypedDataset, we get a compilation error.
                  
 
                  val personDS = TypedDataset.create(people)
-// <console>:32: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]
+// <console>:31: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]
 //        val personDS = TypedDataset.create(people)
 //                                          ^
 
                  
@@ -334,7 +334,7 @@ 
                  Another example
                  
     case 2 => Female
     case 3 => Other
   })
-// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@62c73008
+// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@4d1cf7ad

                  And now we can create our TypedDataset:

                  val personDS = TypedDataset.create(people)
@@ -383,7 +383,7 @@ 
                  No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"next":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"previous":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Injection.md","mtime":"2017-10-18T16:21:39.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-10-18T16:22:33.699Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"next":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"previous":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Injection.md","mtime":"2018-02-18T23:18:59.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/Job.html b/Job.html
index 76839ebab..d12f5b670 100644
--- a/Job.html
+++ b/Job.html
@@ -280,7 +280,7 @@ 
                  Job[A]
                  
     count <- ds.count()
     sample <- ds.take((count/5).toInt)
   } yield sample
-// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@709dd56b
+// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@729d8021
 
 countAndTakeJob.run()
 // res1: Seq[Int] = WrappedArray(1, 2, 3, 4)
@@ -295,7 +295,7 @@ 
                  Job[A]
                  
 // computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]
 
 val finalJob = computeMinOfSample(countAndTakeJob)
-// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@6ef768bf
+// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@30c69a34

                  Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, @@ -357,7 +357,7 @@

                  No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"Job[A]","level":"1.6","depth":1,"next":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"path":"Cats.md","ref":"Cats.md","articles":[]},"previous":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"path":"Injection.md","ref":"Injection.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Job.md","mtime":"2017-10-18T16:21:41.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-10-18T16:22:33.699Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"Job[A]","level":"1.6","depth":1,"next":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"path":"Cats.md","ref":"Cats.md","articles":[]},"previous":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"path":"Injection.md","ref":"Injection.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Job.md","mtime":"2018-02-18T23:19:00.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}}); }); diff --git a/TypedDataFrame.html b/TypedDataFrame.html index a4f0c58b8..ecf083efa 100644 --- a/TypedDataFrame.html +++ b/TypedDataFrame.html @@ -250,8 +250,8 @@

                  Proof of Concept: TypedDataFrame

                  -

                  TypedDataFrame is the API developed in the early stages of frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future developments of frameless. However, the design is interesting enough for being documented.

                  -

                  To safely manipulate DataFrames we use a technique called shadow type, which consists in storing additional information about a value in a "dummy" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.

                  +

                  TypedDataFrame is the API developed in the early stages of Frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future development of Frameless. However, the design is interesting enough to document.

                  +

                  To safely manipulate DataFrames we use a technique called a shadow type, which consists in storing additional information about a value in a "dummy" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.

                  Diving in

                  In TypedDataFrame, we use a single Schema <: Product to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:

                  import org.apache.spark.sql.DataFrame
@@ -270,7 +270,7 @@ 
                  Diving in

                  As you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.

                  Type-level column referencing

                  -

                  For Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching column referencing at compile type. When everything goes well, frameless select is very similar to vanilla select, except that it keeps track of the selected column types:

                  +

                  For Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching invalid column references compile type. When everything goes well, Frameless select is very similar to vanilla select, except that it keeps track of the selected column types:

                  import frameless.TypedDataFrame
 
 case class Foo(s: String, d: Double, i: Int)
@@ -278,26 +278,26 @@ 
                  Type-level column referencing
                  
 def selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =
   tf.select('i, 's)
                  -

                  However, in case of typo, it gets coughs right away:

                  +

                  However, in case of typo, it gets caught right away:

                  def selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =
   tf.select('j, 's)

                  Type-level joins

                  -

                  Joins can available with two different syntaxes, the first lets you reference different columns on each TypedDataFrame, and ensures that their all exists and have compatible types:

                  +

                  Joins can available with two different syntaxes. The first lets you reference different columns on each TypedDataFrame, and ensures that they all exist and have compatible types:

                  case class Bar(i: Int, j: String, b: Boolean)
 
 def join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])
     : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =
   tf1.innerJoin(tf2).on('s).and('j)
                  -

                  The second syntax bring some convenience when the joining columns have identical names in both tables:

                  +

                  The second syntax brings some convenience when the joining columns have identical names in both tables:

                  def join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])
     : TypedDataFrame[(String, Double, Int, String, Boolean)] =
   tf1.innerJoin(tf2).using('i)

                  Further example are available in the TypedDataFrame join tests.

                  Complete example

                  -

                  We now consider a complete example to see how the type system can frameless can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city map and neighborhood:

                  +

                  We now consider a complete example to see how the Frameless types can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city maps and neighborhoods:

                  type Neighborhood = String
 type Address = String
 
@@ -319,7 +319,7 @@ 
                  Complete example
                  
   def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))
 }
                  -

                  Suppose we manage to obtain a TypedDataFrame[PhoneBookEntry] and a TypedDataFrame[CityMapEntry] public data, here is what our Spark job could look like with frameless:

                  +

                  Suppose we manage to obtain public data for a TypedDataFrame[PhoneBookEntry] and TypedDataFrame[CityMapEntry]. Here is what our Spark job could look like with Frameless:

                  import org.apache.spark.sql.SQLContext
 
 // These case classes are used to hold intermediate results
@@ -348,10 +348,10 @@ 
                  Complete example
                  
     .head._1
 }
                  -

                  If you compare this version from Spark vanilla where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.

                  +

                  If you compare this version to vanilla Spark where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.

                  Limitations

                  The main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.

                  -

                  In the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.

                  +

                  In the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in Frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.

                  @@ -391,7 +391,7 @@

                  No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"Proof of Concept: TypedDataFrame","level":"1.9","depth":1,"previous":{"title":"Using Spark ML with TypedDataset","level":"1.8","depth":1,"path":"TypedML.md","ref":"TypedML.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedDataFrame.md","mtime":"2017-10-18T16:21:41.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-10-18T16:22:33.699Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"Proof of Concept: TypedDataFrame","level":"1.9","depth":1,"previous":{"title":"Using Spark ML with TypedDataset","level":"1.8","depth":1,"path":"TypedML.md","ref":"TypedML.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedDataFrame.md","mtime":"2018-02-18T23:19:01.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}}); }); diff --git a/TypedDatasetVsSparkDataset.html b/TypedDatasetVsSparkDataset.html index 99ecfc719..104096cb3 100644 --- a/TypedDatasetVsSparkDataset.html +++ b/TypedDatasetVsSparkDataset.html @@ -253,8 +253,8 @@

                  Comparing TypedDatasets with Spark's Datasets

                  Goal: - This tutorial compares the standard Spark Datasets api with the one provided by - frameless' TypedDataset. It shows how TypedDatsets allows for an expressive and + This tutorial compares the standard Spark Datasets API with the one provided by + Frameless' TypedDataset. It shows how TypedDatasets allow for an expressive and type-safe api with no compromises on performance.

                  For this tutorial we first create a simple dataset and save it on disk as a parquet file. Parquet is a popular columnar format and well supported by Spark. @@ -310,9 +310,9 @@

                  Comparing TypedDatasets wi Now, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.

                  filteredDs.explain()
 // == Physical Plan ==
-// *Project [i#1131L]
-// +- *Filter (isnotnull(i#1131L) && (i#1131L = 10))
-//    +- *FileScan parquet [i#1131L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct<i:bigint>
+// *Project [i#1771L]
+// +- *Filter (isnotnull(i#1771L) && (i#1771L = 10))
+//    +- *FileScan parquet [i#1771L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct<i:bigint>

                  The last line is very important (see ReadSchema). The schema read from the parquet file only required reading column i without needing to access column j. @@ -322,8 +322,8 @@

                  Comparing TypedDatasets wi 
                  scala> ds.filter($"i" === 10).select($"x".as[Long])
 org.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];;
 'Project ['x]
-+- Filter (i#1131L = cast(10 as bigint))
-   +- Relation[i#1131L,j#1132] parquet
++- Filter (i#1771L = cast(10 as bigint))
+   +- Relation[i#1771L,j#1772] parquet
 
   at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)
   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:88)
@@ -353,15 +353,14 @@ 
                  Comparing TypedDatasets wi
   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)
   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)
   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)
-  at org.apache.spark.sql.Dataset.<init>(Dataset.scala:164)
-  at org.apache.spark.sql.Dataset.<init>(Dataset.scala:170)
-  at org.apache.spark.sql.Dataset.select(Dataset.scala:1213)
+  at org.apache.spark.sql.Dataset.<init>(Dataset.scala:165)
+  at org.apache.spark.sql.Dataset.<init>(Dataset.scala:171)
+  at org.apache.spark.sql.Dataset.select(Dataset.scala:1210)
   ... 454 elided
                  -

                  There are two things to improve here. First, we would want to avoid the at[Long] casting that we are required -to type for type-safety. This is clearly an area where we can introduce a bug by casting to an incompatible -type. Second, we want a solution where reference to a -non existing column name fails at compilation time. +

                  There are two things to improve here. First, we would want to avoid the as[Long] casting that we are required +to type for type-safety. This is clearly an area where we may introduce a bug by casting to an incompatible +type. Second, we want a solution where reference to a non existing column name fails at compilation time. The standard Spark Dataset can achieve this using the following syntax.

                  ds.filter(_.i == 10).map(_.i).show()
 // +-----+
@@ -382,20 +381,19 @@ 
                  Comparing TypedDatasets wi
 
                  Unfortunately, this syntax does not allow Spark to optimize the code.
                  
 
                  ds.filter(_.i == 10).map(_.i).explain()
 // == Physical Plan ==
-// *SerializeFromObject [input[0, bigint, false] AS value#1165L]
-// +- *MapElements <function1>, obj#1164: bigint
+// *SerializeFromObject [input[0, bigint, false] AS value#1805L]
+// +- *MapElements <function1>, obj#1804: bigint
 //    +- *Filter <function1>.apply
-//       +- *DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#1163: $line14.$read$$iw$$iw$$iw$$iw$Foo
-//          +- *FileScan parquet [i#1131L,j#1132] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [], ReadSchema: struct<i:bigint,j:string>
+//       +- *DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#1803: $line14.$read$$iw$$iw$$iw$$iw$Foo
+//          +- *FileScan parquet [i#1771L,j#1772] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [], ReadSchema: struct<i:bigint,j:string>
 
                  
 
                  As we see from the explained Physical Plan, Spark was not able to optimize our query as before.
 Reading the parquet file will required loading all the fields of Foo. This might be ok for
 small datasets or for datasets with few columns, but will be extremely slow for most practical
-applications.
-Intuitively, Spark currently doesn't have a way to look inside the code we pass in these two
+applications. Intuitively, Spark currently does not have a way to look inside the code we pass in these two
 closures. It only knows that they both take one argument of type Foo, but it has no way of knowing if
 we use just one or all of Foo's fields.
                  
-
                  The TypedDataset in frameless solves this problem. It allows for a simple and type-safe syntax
+
                  The TypedDataset in Frameless solves this problem. It allows for a simple and type-safe syntax
 with a fully optimized query plan.
                  
 
                  import frameless.TypedDataset
 // import frameless.TypedDataset
@@ -406,7 +404,7 @@ 
                  Comparing TypedDatasets wi
 val fds = TypedDataset.create(ds)
 // fds: frameless.TypedDataset[Foo] = [i: bigint, j: string]
 
-fds.filter( fds('i) === 10 ).select( fds('i) ).show().run()
+fds.filter(fds('i) === 10).select(fds('i)).show().run()
 // +---+
 // | _1|
 // +---+
@@ -415,17 +413,17 @@ 
                  Comparing TypedDatasets wi
 //
 
                  
 
                  And the optimized Physical Plan:
                  
-
                  fds.filter( fds('i) === 10 ).select( fds('i) ).explain()
+
                  fds.filter(fds('i) === 10).select(fds('i)).explain()
 // == Physical Plan ==
-// *Project [i#1131L AS _1#1236L]
-// +- *Filter (isnotnull(i#1131L) && (i#1131L = 10))
-//    +- *FileScan parquet [i#1131L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct<i:bigint>
+// *Project [i#1771L AS _1#1876L]
+// +- *Filter (isnotnull(i#1771L) && (i#1771L = 10))
+//    +- *FileScan parquet [i#1771L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct<i:bigint>
 
                  
 
                  And the compiler is our friend.
                  
-
                  scala> fds.filter( fds('i) === 10 ).select( fds('x) )
+
                  scala> fds.filter(fds('i) === 10).select(fds('x))
 <console>:24: error: No column Symbol with shapeless.tag.Tagged[String("x")] of type A in Foo
-       fds.filter( fds('i) === 10 ).select( fds('x) )
-                                               ^
+       fds.filter(fds('i) === 10).select(fds('x))
+                                            ^
 
                  
 
                  Differences in Encoders
                  
 
                  Encoders in Spark's Datasets are partially type-safe. If you try to create a Dataset using  a type that is not 
@@ -448,27 +446,106 @@ 
                  Differences in Encoders
                  
 // java.lang.UnsupportedOperationException: No Encoder found for java.util.Date
 // - field (class: "java.util.Date", name: "jday")
 // - root class: "MyDate"
-//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:625)
-//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$10.apply(ScalaReflection.scala:619)
-//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$10.apply(ScalaReflection.scala:607)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:632)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:455)
+//   at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:56)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$class.cleanUpReflectionObjects(ScalaReflection.scala:809)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:39)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:455)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1$$anonfun$10.apply(ScalaReflection.scala:626)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1$$anonfun$10.apply(ScalaReflection.scala:614)
 //   at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)
 //   at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)
 //   at scala.collection.immutable.List.foreach(List.scala:392)
 //   at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)
 //   at scala.collection.immutable.List.flatMap(List.scala:355)
-//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:607)
-//   at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:438)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:614)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:455)
+//   at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:56)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$class.cleanUpReflectionObjects(ScalaReflection.scala:809)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:39)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:455)
+//   at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:444)
 //   at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:71)
 //   at org.apache.spark.sql.Encoders$.product(Encoders.scala:275)
 //   at org.apache.spark.sql.LowPrioritySQLImplicits$class.newProductEncoder(SQLImplicits.scala:233)
 //   at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:33)
-//   ... 778 elided
+//   ... 770 elided
 
                  
 
                  In comparison, a TypedDataset will notify about the encoding problem at compile time: 
                  
 
                  TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))
 // <console>:25: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[MyDate]
 //        TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))
 //                           ^
+
                  
+
                  Aggregate vs Projected columns
                  
+
                  Spark's Dataset do not distinguish between columns created from aggregate operations, 
+such as summing or averaging, and simple projections/selections. 
+This is problematic when you start mixing the two.
                  
+
                  import org.apache.spark.sql.functions.sum
+// import org.apache.spark.sql.functions.sum
+
                  
+
                  ds.select(sum($"i"), $"i"*2)
+// org.apache.spark.sql.AnalysisException: grouping expressions sequence is empty, and '`i`' is not an aggregate function. Wrap '(sum(`i`) AS `sum(i)`)' in windowing function(s) or wrap '`i`' in first() (or first_value) if you don't care which value you get.;;
+// Aggregate [sum(i#1771L) AS sum(i)#1889L, (i#1771L * cast(2 as bigint)) AS (i * 2)#1890L]
+// +- Relation[i#1771L,j#1772] parquet
+// 
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.failAnalysis(CheckAnalysis.scala:39)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.failAnalysis(Analyzer.scala:91)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1(CheckAnalysis.scala:239)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)
+//   at scala.collection.immutable.List.foreach(List.scala:392)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1(CheckAnalysis.scala:253)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)
+//   at scala.collection.immutable.List.foreach(List.scala:392)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1(CheckAnalysis.scala:253)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$9.apply(CheckAnalysis.scala:280)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$9.apply(CheckAnalysis.scala:280)
+//   at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)
+//   at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:280)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)
+//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)
+//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:67)
+//   at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2884)
+//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1150)
+//   ... 854 elided
+
                  
+
                  In Frameless, mixing the two results in a compilation error.
                  
+
                  // To avoid confusing frameless' sum with the standard Spark's sum
+import frameless.functions.aggregate.{sum => fsum}
+// import frameless.functions.aggregate.{sum=>fsum}
+
                  
+
                  fds.select(fsum(fds('i)))
+// <console>:26: error: polymorphic expression cannot be instantiated to expected type;
+//  found   : [Out]frameless.TypedAggregate[Foo,Out]
+//  required: frameless.TypedColumn[Foo,?]
+//        fds.select(fsum(fds('i)))
+//                       ^
+
                  
+
                  As the error suggests, we expected a TypedColumn but we got a TypedAggregate instead. 
                  
+
                  Here is how you apply an aggregation method in Frameless: 
                  
+
                  fds.agg(fsum(fds('i))+22).show().run()
+// +---+
+// | _1|
+// +---+
+// |133|
+// +---+
+//
+
                  
+
                  Similarly, mixing projections while aggregating does not make sense, and in Frameless
+you get a compilation error.  
                  
+
                  fds.agg(fsum(fds('i)), fds('i)).show().run()
+// <console>:26: error: polymorphic expression cannot be instantiated to expected type;
+//  found   : [A]frameless.TypedColumn[Foo,A]
+//  required: frameless.TypedAggregate[Foo,?]
+//        fds.agg(fsum(fds('i)), fds('i)).show().run()
+//                                  ^
 
                  
 
                                 
@@ -513,7 +590,7 @@ 
                  No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"next":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"previous":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"path":"FeatureOverview.md","ref":"FeatureOverview.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedDatasetVsSparkDataset.md","mtime":"2017-10-18T16:21:46.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-10-18T16:22:33.699Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"next":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"previous":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"path":"FeatureOverview.md","ref":"FeatureOverview.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedDatasetVsSparkDataset.md","mtime":"2018-02-18T23:19:06.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/TypedEncoder.html b/TypedEncoder.html
index 24924f432..0beaf6c3f 100644
--- a/TypedEncoder.html
+++ b/TypedEncoder.html
@@ -252,39 +252,24 @@ 
                  
                                 
                  
                                 
                                 
                  Typed Encoders in Frameless
                  
-
                  Spark uses Reflection to derive it's Encoders, which is why they can fail at run time. For example, because Spark does not supports java.util.Date, the following leads to an error:
                  
+
                  Spark uses Reflection to derive its Encoders, which is why they can fail at run time. For example, because Spark does not support java.util.Date, the following leads to an error:
                  
 
                  import org.apache.spark.sql.Dataset
 import spark.implicits._
 
 case class DateRange(s: java.util.Date, e: java.util.Date)
 
                  
 
                  scala> val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))
-java.lang.UnsupportedOperationException: No Encoder found for java.util.Date
-- field (class: "java.util.Date", name: "s")
-- root class: "DateRange"
-  at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:625)
-  at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$10.apply(ScalaReflection.scala:619)
-  at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$10.apply(ScalaReflection.scala:607)
-  at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)
-  at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)
-  at scala.collection.immutable.List.foreach(List.scala:392)
-  at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)
-  at scala.collection.immutable.List.flatMap(List.scala:355)
-  at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:607)
-  at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:438)
-  at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:71)
-  at org.apache.spark.sql.Encoders$.product(Encoders.scala:275)
-  at org.apache.spark.sql.LowPrioritySQLImplicits$class.newProductEncoder(SQLImplicits.scala:233)
-  at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:33)
-  ... 242 elided
+<console>:24: error: not found: value sqlContext
+       val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))
+                                    ^
 
                  
-
                  As shown by the stack trace, this runtime error goes thought ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection based approach is it's inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.
                  
-
                  Frameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the code java.util.Date example won't compile with frameless:
                  
+
                  As shown by the stack trace, this runtime error goes through ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection-based approach is its inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.
                  
+
                  Frameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every Frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless' type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the java.util.Date example won't compile with Frameless:
                  
 
                  import frameless.TypedDataset
 import frameless.syntax._
 
                  
 
                  val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))
-// <console>:29: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]
+// <console>:28: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]
 //        val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))
 //                                                             ^
 
                  
@@ -299,18 +284,18 @@ 
                  Typed Encoders in Frameless
                  
 // ds: frameless.TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>]
 
 ds.collect()
-// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@208e2282
+// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@558c6c17
 
                  
 
                  But any non-encodable in the case class hierarchy will be detected at compile time:
                  
 
                  case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
 
                  
 
                  val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, "s", new java.util.Date))))
-// <console>:31: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]
+// <console>:30: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]
 //        val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, "s", new java.util.Date))))
 //                                                           ^
 
                  
-
                  It should be noted that once derived, reflection based Encoders and implicitly derived TypeEncoders have identical performances. The derivation mechanism is different, but the objects generated to encode and decode JVM object in the Spark internal representation behave the same at run-time.
                  
+
                  It should be noted that once derived, reflection-based Encoders and implicitly derived TypeEncoders have identical performance. The derivation mechanism is different, but the objects generated to encode and decode JVM objects in Spark's internal representation behave the same at runtime.

                @@ -354,7 +339,7 @@

                No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"next":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"path":"Injection.md","ref":"Injection.md","articles":[]},"previous":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedEncoder.md","mtime":"2017-10-18T16:21:48.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-10-18T16:22:33.699Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"next":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"path":"Injection.md","ref":"Injection.md","articles":[]},"previous":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedEncoder.md","mtime":"2018-02-18T23:19:08.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}}); }); diff --git a/TypedML.html b/TypedML.html index 0d35ac599..8db51c590 100644 --- a/TypedML.html +++ b/TypedML.html @@ -251,23 +251,292 @@

                -

                TypedDataset support for Spark ML

                -

                The goal of the frameless-ml module is to be able to use Spark ML with TypedDataset and -to eventually provide a more strongly typed ML API for Spark. Currently, this module is at its very beginning and only -provides TypedEncoder instances for Spark ML's linear algebra data types.

                -

                Using Vector and Matrix with TypedDataset

                -

                frameless-ml provides TypedEncoder instances for org.apache.spark.ml.linalg.Vector -and org.apache.spark.ml.linalg.Matrix:

                -
                import frameless.ml._
-// import frameless.ml._
+                                
                Typed Spark ML
                
+
                The frameless-ml module provides a strongly typed Spark ML API leveraging TypedDatasets. It introduces TypedTransformers
+and TypedEstimators, the type-safe equivalents of Spark ML's Transformer and Estimator. 
                
+
                A TypedEstimator fits models to data, i.e trains a ML model based on an input TypedDataset. 
+A TypedTransformer transforms one TypedDataset into another, usually by appending column(s) to it.
                
+
                By calling the fit method of a TypedEstimator, the TypedEstimator will train a ML model using the TypedDataset 
+passed as input (representing the training data) and will return a TypedTransformer that represents the trained model. 
+This TypedTransformercan then be used to make predictions on an input TypedDataset (representing the test data) 
+using the transform method that will return a new TypedDataset with appended prediction column(s).
                
+
                Both TypedEstimator and TypedTransformer check at compile-time the correctness of their inputs field names and types,
+contrary to Spark ML API which only deals with DataFrames (the data structure with the lowest level of type-safety in Spark).
                
+
                frameless-ml adds type-safety to Spark ML API but stays very close to it in terms of abstractions and API calls, so 
+please check Spark ML documentation for more details 
+on Transformers and Estimators.
                
+
                Example 1: predict a continuous value using a TypedRandomForestRegressor
                
+
                In this example, we want to predict the sale price of a house depending on its square footage and the fact that the house
+has a garden or not. We will use a TypedRandomForestRegressor.
                
+
                Training
                
+
                As with the Spark ML API, we use a TypedVectorAssembler (the type-safe equivalent of VectorAssembler)
+to compute feature vectors:
                
+
                import frameless._
+import frameless.syntax._
+import frameless.ml._
+import frameless.ml.feature._
+import frameless.ml.regression._
+import org.apache.spark.ml.linalg.Vector
+
                
+
                case class HouseData(squareFeet: Double, hasGarden: Boolean, price: Double)
+// defined class HouseData
 
-import frameless.TypedDataset
-// import frameless.TypedDataset
+val trainingData = TypedDataset.create(Seq(
+  HouseData(20, false, 100000),
+  HouseData(50, false, 200000),
+  HouseData(50, true, 250000),
+  HouseData(100, true, 500000)
+))
+// trainingData: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]
 
-import org.apache.spark.ml.linalg._
-// import org.apache.spark.ml.linalg._
+case class Features(squareFeet: Double, hasGarden: Boolean)
+// defined class Features
+
+val assembler = TypedVectorAssembler[Features]
+// assembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@159b3f1
+
+case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector)
+// defined class HouseDataWithFeatures
+
+val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures]
+// trainingDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]
+
                
+
                In the above code snippet, .as[HouseDataWithFeatures] is a TypedDataset's type-safe cast
+(see TypedDataset: Feature Overview):
                
+
                case class WrongHouseFeatures(
+  squareFeet: Double,
+  hasGarden: Int, // hasGarden has wrong type
+  price: Double,
+  features: Vector
+)
+
                
+
                assembler.transform(trainingData).as[WrongHouseFeatures]
+// <console>:39: error: could not find implicit value for parameter as: frameless.ops.As[(Double, Boolean, Double, org.apache.spark.ml.linalg.Vector),WrongHouseFeatures]
+//        assembler.transform(trainingData).as[WrongHouseFeatures]
+//                                            ^
+
                
+
                Moreover, TypedVectorAssembler[Features] will compile only if Features contains exclusively fields of type Numeric or Boolean:
                
+
                case class WrongFeatures(squareFeet: Double, hasGarden: Boolean, city: String)
+
                
+
                TypedVectorAssembler[WrongFeatures]
+// <console>:37: error: Cannot prove that WrongFeatures is a valid input type. Input type must only contain fields of numeric or boolean types.
+//        TypedVectorAssembler[WrongFeatures]
+//                            ^
+
                
+
                The subsequent call assembler.transform(trainingData) compiles only if trainingData contains all fields (names and types)
+of Features:
                
+
                case class WrongHouseData(squareFeet: Double, price: Double) // hasGarden is missing
+// defined class WrongHouseData
+
+val wrongTrainingData = TypedDataset.create(Seq(WrongHouseData(20, 100000)))
+// wrongTrainingData: frameless.TypedDataset[WrongHouseData] = [squareFeet: double, price: double]
+
                
+
                assembler.transform(wrongTrainingData)
+// <console>:37: error: Cannot prove that WrongHouseData can be projected to Features. Perhaps not all member names and types of Features are the same in WrongHouseData?
+//        assembler.transform(wrongTrainingData)
+//                           ^
+
                
+
                Then, we train the model. To train a Random Forest, one needs to feed it with features (what we predict from) and
+with a label (what we predict). In our example, price is the label, features are the features:
                
+
                case class RFInputs(price: Double, features: Vector)
+// defined class RFInputs
+
+val rf = TypedRandomForestRegressor[RFInputs]
+// rf: frameless.ml.regression.TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@4c620c93
+
+val model = rf.fit(trainingDataWithFeatures).run()
+// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.regression.TypedRandomForestRegressor.Outputs,org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anonfun$fit$1$$anon$1@36ed2d44
+
                
+
                TypedRandomForestRegressor[RFInputs] compiles only if RFInputs
+contains only one field of type Double (the label) and one field of type Vector (the features):
                
+
                case class WrongRFInputs(labelOfWrongType: String, features: Vector)
+
                
+
                TypedRandomForestRegressor[WrongRFInputs]
+// <console>:37: error: Cannot prove that WrongRFInputs is a valid input type. Input type must only contain a field of type Double (the label) and a field of type org.apache.spark.ml.linalg.Vector (the features).
+//        TypedRandomForestRegressor[WrongRFInputs]
+//                                  ^
+
                
+
                The subsequent rf.fit(trainingDataWithFeatures) call compiles only if trainingDataWithFeatures contains the same fields
+(names and types) as RFInputs.
                
+
                val wrongTrainingDataWithFeatures = TypedDataset.create(Seq(HouseData(20, false, 100000))) // features are missing
+// wrongTrainingDataWithFeatures: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]
+
                
+
                rf.fit(wrongTrainingDataWithFeatures) 
+// <console>:37: error: Cannot prove that HouseData can be projected to RFInputs. Perhaps not all member names and types of RFInputs are the same in HouseData?
+//        rf.fit(wrongTrainingDataWithFeatures)
+//              ^
+
                
+
                Prediction
                
+
                We now want to predict price for testData using the previously trained model. Like the Spark ML API,
+testData has a default value for price (0 in our case) that will be ignored at prediction time. We reuse
+our assembler to compute the feature vector of testData.
                
+
                val testData = TypedDataset.create(Seq(HouseData(70, true, 0)))
+// testData: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]
+
+val testDataWithFeatures = assembler.transform(testData).as[HouseDataWithFeatures]
+// testDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]
+
+case class HousePricePrediction(
+  squareFeet: Double,
+  hasGarden: Boolean,
+  price: Double,
+  features: Vector,
+  predictedPrice: Double
+)
+// defined class HousePricePrediction
+
+val predictions = model.transform(testDataWithFeatures).as[HousePricePrediction]
+// predictions: frameless.TypedDataset[HousePricePrediction] = [squareFeet: double, hasGarden: boolean ... 3 more fields]
+
+predictions.select(predictions.col('predictedPrice)).collect.run()
+// res6: Seq[Double] = WrappedArray(420000.0)
+
                
+
                model.transform(testDataWithFeatures) will only compile if testDataWithFeatures contains a field price of type Double
+and a field features of type Vector:
                
+
                model.transform(testData)
+// <console>:37: error: Cannot prove that HouseData can be projected to RFInputs. Perhaps not all member names and types of RFInputs are the same in HouseData?
+//        model.transform(testData)
+//                       ^
+
                
+
                Example 2: predict a categorical value using a TypedRandomForestClassifier
                
+
                In this example, we want to predict in which city a house is located depending on its price and its square footage. We use a
+TypedRandomForestClassifier.
                
+
                Training
                
+
                As with the Spark ML API, we use a TypedVectorAssembler to compute feature vectors and a TypedStringIndexer
+to index city values in order to be able to pass them to a TypedRandomForestClassifier
+(which only accepts Double values as label):
                
+
                import frameless.ml.classification._
+
                
+
                case class HouseData(squareFeet: Double, city: String, price: Double)
+// defined class HouseData
+
+val trainingData = TypedDataset.create(Seq(
+  HouseData(100, "lyon", 100000),
+  HouseData(200, "lyon", 200000),
+  HouseData(100, "san francisco", 500000),
+  HouseData(150, "san francisco", 900000)
+))
+// trainingData: frameless.TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]
+
+case class Features(price: Double, squareFeet: Double)
+// defined class Features
+
+val vectorAssembler = TypedVectorAssembler[Features]
+// vectorAssembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@66b12f1
+
+case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector)
+// defined class HouseDataWithFeatures
 
-val vector = Vectors.dense(1, 2, 3)
+val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures]
+// dataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]
+
+case class StringIndexerInput(city: String)
+// defined class StringIndexerInput
+
+val indexer = TypedStringIndexer[StringIndexerInput]
+// indexer: frameless.ml.feature.TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@666bcbec
+
+val indexerModel = indexer.fit(dataWithFeatures).run()
+// indexerModel: frameless.ml.AppendTransformer[StringIndexerInput,frameless.ml.feature.TypedStringIndexer.Outputs,org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anonfun$fit$1$$anon$1@5a0797e
+
+case class HouseDataWithFeaturesAndIndex(
+  squareFeet: Double,
+  city: String,
+  price: Double,
+  features: Vector,
+  cityIndexed: Double
+)
+// defined class HouseDataWithFeaturesAndIndex
+
+val indexedData = indexerModel.transform(dataWithFeatures).as[HouseDataWithFeaturesAndIndex]
+// indexedData: frameless.TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]
+
                
+
                Then, we train the model:
                
+
                case class RFInputs(cityIndexed: Double, features: Vector)
+// defined class RFInputs
+
+val rf = TypedRandomForestClassifier[RFInputs]
+// rf: frameless.ml.classification.TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@be7eeed
+
+val model = rf.fit(indexedData).run()
+// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.classification.TypedRandomForestClassifier.Outputs,org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anonfun$fit$1$$anon$1@20355c2f
+
                
+
                Prediction
                
+
                We now want to predict city for testData using the previously trained model. Like the Spark ML API,
+testData has a default value for city (empty string in our case) that will be ignored at prediction time. We reuse
+our vectorAssembler to compute the feature vector of testData and our indexerModel to index city.
                
+
                val testData = TypedDataset.create(Seq(HouseData(120, "", 800000)))
+// testData: frameless.TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]
+
+val testDataWithFeatures = vectorAssembler.transform(testData).as[HouseDataWithFeatures]
+// testDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]
+
+val indexedTestData = indexerModel.transform(testDataWithFeatures).as[HouseDataWithFeaturesAndIndex]
+// indexedTestData: frameless.TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]
+
+case class HouseCityPredictionInputs(features: Vector, cityIndexed: Double)
+// defined class HouseCityPredictionInputs
+
+val testInput = indexedTestData.project[HouseCityPredictionInputs]
+// testInput: frameless.TypedDataset[HouseCityPredictionInputs] = [features: vector, cityIndexed: double]
+
+case class HouseCityPredictionIndexed(
+  features: Vector,
+  cityIndexed: Double,
+  rawPrediction: Vector,
+  probability: Vector,
+  predictedCityIndexed: Double
+)
+// defined class HouseCityPredictionIndexed
+
+val indexedPredictions = model.transform(testInput).as[HouseCityPredictionIndexed]
+// indexedPredictions: frameless.TypedDataset[HouseCityPredictionIndexed] = [features: vector, cityIndexed: double ... 3 more fields]
+
                
+
                Then, we use a TypedIndexToString to get back a String value from predictedCityIndexed. TypedIndexToString takes
+as input the label array computed by our previous indexerModel:
                
+
                case class IndexToStringInput(predictedCityIndexed: Double)
+// defined class IndexToStringInput
+
+val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
+// indexToString: frameless.ml.feature.TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@c97d749
+
+case class HouseCityPrediction(
+  features: Vector,
+  cityIndexed: Double,
+  rawPrediction: Vector,
+  probability: Vector,
+  predictedCityIndexed: Double,
+  predictedCity: String
+)
+// defined class HouseCityPrediction
+
+val predictions = indexToString.transform(indexedPredictions).as[HouseCityPrediction]
+// predictions: frameless.TypedDataset[HouseCityPrediction] = [features: vector, cityIndexed: double ... 4 more fields]
+
+predictions.select(predictions.col('predictedCity)).collect.run()
+// res8: Seq[String] = WrappedArray(san francisco)
+
                
+
                List of currently implemented TypedEstimators
                
+
+
                List of currently implemented TypedTransformers
                
+
+
                Using Vector and Matrix with TypedDataset
                
+
                frameless-ml provides TypedEncoder instances for org.apache.spark.ml.linalg.Vector 
+and org.apache.spark.ml.linalg.Matrix:
                
+
                import frameless._
+import frameless.ml._
+import org.apache.spark.ml.linalg._
+
                
+
                val vector = Vectors.dense(1, 2, 3)
 // vector: org.apache.spark.ml.linalg.Vector = [1.0,2.0,3.0]
 
 val vectorDs = TypedDataset.create(Seq("label" -> vector))
@@ -327,7 +596,7 @@ 
                No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Using Spark ML with TypedDataset","level":"1.8","depth":1,"next":{"title":"Proof of Concept: TypedDataFrame","level":"1.9","depth":1,"path":"TypedDataFrame.md","ref":"TypedDataFrame.md","articles":[]},"previous":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"path":"Cats.md","ref":"Cats.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedML.md","mtime":"2017-10-18T16:21:50.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-10-18T16:22:33.699Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Using Spark ML with TypedDataset","level":"1.8","depth":1,"next":{"title":"Proof of Concept: TypedDataFrame","level":"1.9","depth":1,"path":"TypedDataFrame.md","ref":"TypedDataFrame.md","articles":[]},"previous":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"path":"Cats.md","ref":"Cats.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedML.md","mtime":"2018-02-18T23:19:23.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/docs/src/main/tut/README.md b/docs/src/main/tut/README.md
index 1cd3be47f..9725982f7 100644
--- a/docs/src/main/tut/README.md
+++ b/docs/src/main/tut/README.md
@@ -5,53 +5,80 @@
 [![Maven Badge](https://img.shields.io/maven-central/v/org.typelevel/frameless-dataset_2.11.svg)](https://maven-badges.herokuapp.com/maven-central/org.typelevel/frameless-dataset_2.11)
 [![Gitter Badge](https://badges.gitter.im/typelevel/frameless.svg)](https://gitter.im/typelevel/frameless)
 
-Frameless is a proof-of-concept library for working with [Spark](http://spark.apache.org/) using more expressive types.
+Frameless is a Scala library for working with [Spark](http://spark.apache.org/) using more expressive types. 
 It consists of the following modules:
 
-* `dataset` for more strongly typed `Dataset`s  (supports Spark 2.0.x)
-* `cats` for using Spark with [cats](https://github.com/typelevel/cats) (supports Cats 0.9.x)
-* `ml` for a more strongly typed use of Spark ML based on `dataset`
+* `frameless-dataset` for a more strongly typed `Dataset`/`DataFrame` API   
+* `frameless-ml` for a more strongly typed Spark ML API based on `frameless-dataset`
+* `frameless-cats` for using Spark's `RDD` API with [cats](https://github.com/typelevel/cats)
+
+Note that while Frameless is still getting off the ground, it is very possible that breaking changes will be
+made for at least the next few versions.
 
 The Frameless project and contributors support the
 [Typelevel](http://typelevel.org/) [Code of Conduct](http://typelevel.org/conduct.html) and want all its
 associated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning.
 
+
+## Versions and dependencies
+
+The compatible versions of [Spark](http://spark.apache.org/) and 
+[cats](https://github.com/typelevel/cats) are as follows:   
+
+| Frameless  | Spark | Cats | 
+| --- | --- | --- |
+| 0.4.0  | 2.2.0  | 1.0.0-MF |
+| 0.4.1  | 2.2.0  | 1.0.1 | 
+| 0.5.0  | 2.2.1  | 1.0.1 |
+
+
+The **only** dependency of the `frameless-dataset` module is on [shapeless](https://github.com/milessabin/shapeless) 2.3.2. 
+Therefore, depending on `frameless-dataset`, has a minimal overhead on your Spark's application jar. 
+Only the `frameless-cats` module depends on cats, so if you prefer to work just with `Datasets` and not with `RDD`s, 
+you may choose not to depend on `frameless-cats`. 
+
+Frameless intentionally **does not** have a compile dependency on Spark. 
+This essentially allows you to use any version of Frameless with any version of Spark. 
+The aforementioned table simply provides the versions of Spark we officially compile 
+and test Frameless with, but other versions may probably work as well. 
+
+## Why?
+
+Frameless introduces a new Spark API, called `TypedDataset`. 
+The benefits of using `TypedDataset` compared to the standard Spark `Dataset` API are as follows:
+
+* Typesafe columns referencing (e.g., no more runtime errors when accessing non-existing columns)
+* Customizable, typesafe encoders (e.g., if a type does not have an encoder, it should not compile) 
+* Enhanced type signature for built-in functions (e.g., if you apply an arithmetic operation on a non-numeric column, you 
+get a compilation error)
+* Typesafe casting and projectios
+
+Click [here](http://typelevel.org/frameless/TypedDatasetVsSparkDataset.html) for a 
+detailed comparison of `TypedDataset` with Spark's `Dataset` API. 
+
 ## Documentation
 
 * [TypedDataset: Feature Overview](http://typelevel.org/frameless/FeatureOverview.html)
+* [Typed Spark ML](http://typelevel.org/frameless/TypedML.html)
 * [Comparing TypedDatasets with Spark's Datasets](http://typelevel.org/frameless/TypedDatasetVsSparkDataset.html)
 * [Typed Encoders in Frameless](http://typelevel.org/frameless/TypedEncoder.html)
 * [Injection: Creating Custom Encoders](http://typelevel.org/frameless/Injection.html)
 * [Job\[A\]](http://typelevel.org/frameless/Job.html)
 * [Using Cats with RDDs](http://typelevel.org/frameless/Cats.html)
-* [TypedDataset support for Spark ML](http://typelevel.org/frameless/TypedML.html)
 * [Proof of Concept: TypedDataFrame](http://typelevel.org/frameless/TypedDataFrame.html)
 
-## Why?
-
-Benefits of using `TypedDataset` compared to the standard Spark `Dataset` API:
-
-* Typesafe columns referencing and expressions
-* Customizable, typesafe encoders
-* Typesafe casting and projections
-* Enhanced type signature for some built-in functions
-
 ## Quick Start
 Frameless is compiled against Scala 2.11.x.
 
-Note that while Frameless is still getting off the ground, it is very possible that breaking changes will be
-made for at least the next few versions.
-
 To use Frameless in your project add the following in your `build.sbt` file as needed:
 
 ```scala
-resolvers += Resolver.sonatypeRepo("releases")
-
-val framelessVersion = "0.3.0"
+val framelessVersion = "0.5.0"
 
 libraryDependencies ++= List(
-  "org.typelevel" %% "frameless-cats"      % framelessVersion,
-  "org.typelevel" %% "frameless-dataset"   % framelessVersion
+  "org.typelevel" %% "frameless-dataset" % framelessVersion,
+  "org.typelevel" %% "frameless-ml"      % framelessVersion,
+  "org.typelevel" %% "frameless-cats"    % framelessVersion  
 )
 ```
 
@@ -67,9 +94,16 @@ g8 imarios/frameless.g8
 ```bash
 sbt new imarios/frameless.g8
 ```
+
 Typing `sbt console` inside your project will bring up a shell with Frameless
 and all its dependencies loaded (including Spark).
 
+## Need help?
+
+Feel free to messages us on our [gitter](https://gitter.im/typelevel/frameless) 
+channel for any issues/questions.
+
+
 ## Development
 We require at least *one* sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers
 (people who can merge pull requests) are:
diff --git a/index.html b/index.html
index fc6644f33..f7540ea60 100644
--- a/index.html
+++ b/index.html
@@ -254,47 +254,87 @@ 
                Frameless
                
 Codecov Badge
 Maven Badge
 Gitter Badge
                
-
                Frameless is a proof-of-concept library for working with Spark using more expressive types.
+
                Frameless is a Scala library for working with Spark using more expressive types. 
 It consists of the following modules:
                
 
                  
-
                • dataset for more strongly typed Datasets  (supports Spark 2.0.x)
                  • 
-
                • cats for using Spark with cats (supports Cats 0.9.x)
                  • 
-
                • ml for a more strongly typed use of Spark ML based on dataset
                  • 
+
                • frameless-dataset for a more strongly typed Dataset/DataFrame API   
                  • 
+
                • frameless-ml for a more strongly typed Spark ML API based on frameless-dataset
                  • 
+
                • frameless-cats for using Spark's RDD API with cats
                  • 
 
                
+
                Note that while Frameless is still getting off the ground, it is very possible that breaking changes will be
+made for at least the next few versions.
                
 
                The Frameless project and contributors support the
 Typelevel Code of Conduct and want all its
 associated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning.
                
+
                Versions and dependencies
                
+
                The compatible versions of Spark and 
+cats are as follows:   
                
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
                FramelessSparkCats
                0.4.02.2.01.0.0-MF
                0.4.12.2.01.0.1
                0.5.02.2.11.0.1
                
+
                The only dependency of the frameless-dataset module is on shapeless 2.3.2. 
+Therefore, depending on frameless-dataset, has a minimal overhead on your Spark's application jar. 
+Only the frameless-cats module depends on cats, so if you prefer to work just with Datasets and not with RDDs, 
+you may choose not to depend on frameless-cats. 
                
+
                Frameless intentionally does not have a compile dependency on Spark. 
+This essentially allows you to use any version of Frameless with any version of Spark. 
+The aforementioned table simply provides the versions of Spark we officially compile 
+and test Frameless with, but other versions may probably work as well. 
                
+
                Why?
                
+
                Frameless introduces a new Spark API, called TypedDataset. 
+The benefits of using TypedDataset compared to the standard Spark Dataset API are as follows:
                
+
                  
+
                • Typesafe columns referencing (e.g., no more runtime errors when accessing non-existing columns)
                  • 
+
                • Customizable, typesafe encoders (e.g., if a type does not have an encoder, it should not compile) 
                  • 
+
                • Enhanced type signature for built-in functions (e.g., if you apply an arithmetic operation on a non-numeric column, you 
+get a compilation error)
                  • 
+
                • Typesafe casting and projectios
                  • 
+
                
+
                Click here for a 
+detailed comparison of TypedDataset with Spark's Dataset API. 
                
 
                Documentation
                
 
-
                Why?
                
-
                Benefits of using TypedDataset compared to the standard Spark Dataset API:
                
-
                  
-
                • Typesafe columns referencing and expressions
                  • 
-
                • Customizable, typesafe encoders
                  • 
-
                • Typesafe casting and projections
                  • 
-
                • Enhanced type signature for some built-in functions
                  • 
-
                
 
                Quick Start
                
 
                Frameless is compiled against Scala 2.11.x.
                
-
                Note that while Frameless is still getting off the ground, it is very possible that breaking changes will be
-made for at least the next few versions.
                
 
                To use Frameless in your project add the following in your build.sbt file as needed:
                
-
                resolvers += Resolver.sonatypeRepo("releases")
-
-val framelessVersion = "0.3.0"
+
                val framelessVersion = "0.5.0"
 
 libraryDependencies ++= List(
-  "org.typelevel" %% "frameless-cats"      % framelessVersion,
-  "org.typelevel" %% "frameless-dataset"   % framelessVersion
+  "org.typelevel" %% "frameless-dataset" % framelessVersion,
+  "org.typelevel" %% "frameless-ml"      % framelessVersion,
+  "org.typelevel" %% "frameless-cats"    % framelessVersion  
 )
 
                
 
                An easy way to bootstrap a Frameless sbt project:
                
@@ -310,6 +350,9 @@ 
                Quick Start
                
 
                
 
                Typing sbt console inside your project will bring up a shell with Frameless
 and all its dependencies loaded (including Spark).
                
+
                Need help?
                
+
                Feel free to messages us on our gitter 
+channel for any issues/questions.
                
 
                Development
                
 
                We require at least one sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers
 (people who can merge pull requests) are:
                
@@ -363,7 +406,7 @@ 
                No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Introduction","level":"1.1","depth":1,"next":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"path":"FeatureOverview.md","ref":"FeatureOverview.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"README.md","mtime":"2017-10-18T16:21:41.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2017-10-18T16:22:33.699Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Introduction","level":"1.1","depth":1,"next":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"path":"FeatureOverview.md","ref":"FeatureOverview.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"README.md","mtime":"2018-02-18T23:19:00.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/search_index.json b/search_index.json
index 50b381720..cb4e04c55 100644
--- a/search_index.json
+++ b/search_index.json
@@ -1 +1 @@
-{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["\"0.3.0\"","\"frameless","\"org.typelevel\"","%","%%","(e.g.","(includ","(peopl","(support","(thumb",")","++=","+1,","+=","0.13.13:","0.9.x)","2.0","2.0,","2.0.x)","2.11.x.","=",">=","add","adelbertc","against","apach","api:","are:","associ","avail","base","benefit","bootstrap","break","bring","build.sbt","built","cast","cat","cats\"","chang","channel","code","column","compar","compil","concept","concept:","conduct","consist","consol","contribut","contributor","creat","current","custom","customizable,","dataset","dataset\"","depend","develop","document","easi","encod","enhanc","environ","express","featur","few","file","file.","follow","frameless","framelessvers","framelessversion,","friendli","function","g8","get","giter8","github,","gitter)","ground,","http://opensource.org/licenses/apach","imario","imarios/frameless.g8","injection:","insid","instal","introduct","jeremyrsmith","job[a]","kanterov","learning.","librari","librarydepend","licens","list(","load","made","maintain","merg","ml","modules:","more","needed:","new","next","non","note","olivierblanvillain","on","overview","possibl","project","project:","proof","provid","pull","quick","rdd","referenc","requests)","requests.","requir","resolv","resolver.sonatyperepo(\"releases\")","safe","same","sbt","scala","shell","sign","signatur","similar)","simply:","spark","spark'","spark).","spark.","standard","start","still","strongli","support","type","typeddatafram","typeddataset","typeddataset:","typelevel","types.","typesaf","under","up","up,","us","val","veri","versions.","want","way","well","why?","work"],"FeatureOverview.html":["\"false\")","\"paris\")","'`citi`'","'name),","'population)","'price),","'project","(a)","(automated)","(b)","(enjoy","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(in","(lyon,166500.0))","(manual)","(name:","(paris,333333.3333333333),","(string,","(u:","(up","(which","(with",")",").as[aptpricecity].show().run",").as[stats].show().run()","*","+","...","/","//","1),","10,","100,","10000.0,","102|","133000.0,","133000.0|","2","2),","2).as[updatedsurface]","2).show().run()","2.0","200000.0,","200000.0|","2229621),","2229621|","2409.6385542168673,","25,","250000.0,","250000.0|","250|","25|[paris,","27|","2955.5555555555557,","3","3)","3),","300000.0,","300000.0|","325000.0,","325000.0|","343629)","343629|","4","434","4391.891891891892)","4391.891891891892|","45,","4500.0,","450000.0,","450000.0|","450|","47|","50,","500715),","500715|","500|","52|","6833.333333333333|","74,","740|","76|","83,","830|","85|",":27:",":28:",":31:",":33:",":34:",":36:","=","==","=>","['citi]","[1...10]).","[_1:","[city#53,","[city,","[city:","[lyon,500715]|","[nice,343629]|","[out](other:","[ratio:","^","_1|","_2:","_2|","abov","actual","addit","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","agg()","agg(avg(aptds('price))).","aggreg","aggregated,","agree.","align.","allcities:","allcities|","allow","allowed,","allowed.","alternatives:","and/or","anoth","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartmentdetail","apartmentdetails(city:","apartmentdetails?","api","appear","appli","aptd","aptds('price)","aptds('price)))","aptds('price),","aptds('surface))","aptds('surface)).as[apartmentdetails]","aptds('surface),","aptds.","aptds.agg(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)).as[updatedsurface]","apttypedds('city),","apttypedds('city).cast[double]","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.join(citiinfotypedds,","apttypedds.makeudf(pricemodifier)","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds2","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","arguments)","as:","as[bedroomstats]","as[t]","avail","available.","averag","avg(aptds('price)),","avg(aptds('surface)),","avgprice:","avgpricebeds1:","avgpricebeds2:","avgpricebeds3:","avgpricebeds4:","avgprice|","avgsurface:","avgsurface|minsurface|","base","bedroom","bedrooms#56]","bedrooms.","bedrooms:","bedrooms];;","bedroomstat","bedroomstats(","bedroomstats(lyon,some(133000.0),some(200000.0),none,none)","bedroomstats(nice,none,none,some(325000.0),none)","bedroomstats(paris,some(250000.0),some(300000.0),some(450000.0),none)","bedroomstats.collect().run().foreach(println)","bedroomstats.show().run()","bedroomstats:","better","between","boolean","boolean)].","c:","calcul","can't","care","case","case.","cast","cast,","catalystcast.","catalystcast[string,","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name))","city:","cityinfo","cityinfo(city:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|avgpricebeds1|avgpricebeds2|avgpricebeds3|avgpricebeds4|","city|surface|","class","class:","clause.","code","collect","collectset(aptds('city))","column","column.","column:","columns:","combin","compar","compil","compile.","compile:","compiles:","complet","comput","computations.","conf","context","continu","correspond","creat","data","dataset","dataset.","dataset:","defin","detail","directli","divid","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","e:","each","easili","elid","encod","entir","error","error.","error:","evid","exampl","example,","example.","exist","explan","explicitli","express","extra","featur","few","field","fields]","find","five","follow","form","frameless","frameless.catalystcast[string,double]","frameless.catalystdivisible[double,out],","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.functions.aggregate._","frameless.implicits.widen._","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[apartment,double])(implicit","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[bedroomstats]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","frameless.typedencoder[out])frameless.typedcolumn[apartment,out]","function","further","gener","get","give","given","group","groupbi","groupby()","groupby(aptds('city)).","here","here.","here:","however,","id","if(nam","implicit","implicitli","import","inform","initi","input","instanc","instances:","instanti","int","int)","int).","int,","int.","int]","interest","introduc","job","join","lazi","lazy.","let'","lift","localrel","long","look","lyon]|","lyon|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","macro","make","materialize.","math","matter","member","method","method.","min(aptds('surface)),","minimum","minsurface:","miss","missing,","misspel","mistak","more","n","n:","name","name:","need","new","next","next,","nice,","nice|","nice|325000.0|","not,","note","now","null|","number","on","on(1,2,3,4).","oper","operations:","option","option.","option[double])","option[double],","order","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:88)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$6.apply(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1$1.apply(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$transformexpressionsup$1.apply(queryplan.scala:268)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:289)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:268)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:70)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:289)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:127)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:187)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:288)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:66)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2872)","org.apache.spark.sql.dataset.select(dataset.scala:1153)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:52)","org.apache.spark.sql.sparksess","org.apache.spark.{sparkconf,","overload","overview","paramet","particular","per","perform","perhap","pivot","pivot(aptds('bedrooms)).","pivot,","popul","population:","potenti","prefer","preserv","price","price#55,","price,","price/surfac","price:","price:double)","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.collect.run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","proce","project","prove","rais","ratio","ratio:","ratio|","readi","referenc","repl\").set(\"spark.ui.enabled\",","requir","res17:","res6:","res7:","resolv","result","retriev","right?","row","run","run()","safe","safe,","safe.","safety,","safety.","same","scala","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","secondari","see","seem","select","select()","selectmany()","selectmany,","seq(","seq[(string,","seq[double]","set","shapeless.tag.tagged[string(\"citi\")]","shorter","show","show()","simpl","skip","spark","spark.createdataset(apartments)","spark.implicits._","spark.sparkcontext.setloglevel(\"warn\")","spark.sqlcontext","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","sqlcontext","stack","standard","start","stat","stats(","string","string)","string),updatedsurface]","string,","string.","string]","struct,","struct]","subset","suggests,","support","suppos","surfac","surface#54,","surface,","surface,th","surface:","symbol","syntax:","t","tell","ten","three","time","time,","top","trace):","tri","tutori","two","type","type:","typedcolumn","typeddataset","typeddataset.","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","types,","typesaf","typesafeti","typo","u","udf","udf(aptds('city),","udf:","unit:","unlik","unsaf","up","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","val","valid","valu","vector[string])","want","way","wherea","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","work","worked,","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","|","|1000|102|","|276333.3333333333|62.833333333333336|","|4500.0|450000.0|","|6000.0|300000.0|","|[lyon,45,133000.0,1]|","|[lyon,83,200000.0,2]|","|[nice,74,325000.0,3]|","|[paris,100,450000...|[paris,2229621]|","|[paris,25,250000....|[paris,2229621]|","|[paris,50,300000....|[paris,2229621]|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|"],"TypedDatasetVsSparkDataset.html":["\"e\")","\"java.util.date\",","\"jday\")","\"mydate\"","\"q\")","\"w\")","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","&&","'`x`'","'project","(case","(class:","(i#1131l","(int,","(isnotnull(i#1131l)","(look","(see","(the",")",").explain()",").select(",").show().run()","*deserializetoobject","*filescan","*filter","*mapel","*project","*serializefromobject","+",",","...",".appli","//","10","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10|","1|","454","778",":20:",":24:",":25:","::","=","==","===","['x]","[],","[i#1131l","[i#1131l,j#1132]","[i#1131l]","[i,","[i:","[input[0,","[isnotnull(i),","^","_1#1236l]","_1|","above.","access","achiev","act","ad","allow","api","applications.","area","argument","as[long]","assum","at[long]","avoid","bar","bar(1)))","bar(i:","batched:","before.","bigint","bigint))","bigint,","bigint]","bind","both","bug","bulletproof:","captur","case","cast","cast(10","catalyst","class","class:","classes)","clearli","closur","closures.","code","code.","column","columnar","columns,","columns:","compar","comparison,","compil","compromis","content","context","correct.","correctli","creat","current","dataset","dataset.","dataset[long].","datasets,","defin","detail.","detect","differ","discuss","discussion.","disk","doesn't","ds","ds.filter($\"i\"","ds.filter(_.i","ds.show()","ds:","each","elid","encod","encoder:","entir","equalto(i,10)],","error","error:","etc)","exampl","example,","exist","explain","explicitli","express","extrem","e|","fail","failure:","false]","familiar","fd","fds('i)","fds('x)","fds.filter(","fds:","few","field","fields.","file","file.","filter","filteredd","filteredds.explain()","filteredds.show()","filteredds:","find","first","first,","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo,","foo.","format","format:","found","frameless","frameless'","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[mydate]","friend.","fulli","function","futur","generated.","give","given","goal:","great!","guard","handhold","help","here","here.","hold","however,","implement","implicit","import","improv","incompat","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inmemoryfileindex[file:/tmp/foo],","input","insid","int)","introduc","intuitively,","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date(system.currenttimemillis))))","java.util.date)","j|","know","last","lead","let'","limit","line","linux","load","location:","long","long,","look","mac","map","member","members.","mention","mistak","more","mydat","mydate(jday:","name","name:","need","newinstance(class","next","nil","non","note","notifi","now,","obj#1163:","obj#1164:","ok","on","oper","optim","optimizer)","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:88)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:71)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$6.apply(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1$1.apply(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$transformexpressionsup$1.apply(queryplan.scala:268)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:289)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:268)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$10.apply(scalareflection.scala:607)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$10.apply(scalareflection.scala:619)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:607)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:625)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:438)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:70)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:289)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:127)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:187)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:288)","org.apache.spark.sql.dataset.(dataset.scala:164)","org.apache.spark.sql.dataset.(dataset.scala:170)","org.apache.spark.sql.dataset.select(dataset.scala:1213)","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:275)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:52)","org.apache.spark.sql.lowprioritysqlimplicits$class.newproductencoder(sqlimplicits.scala:233)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:33)","os","paramet","parquet","parquet,","partial","partitionfilters:","pass","performance.","physic","plan","plan,","plan.","plan:","popular","practic","primit","problem","problem.","product","product,","provid","pushedfilters:","queri","quick","q|","read","readschema).","readschema:","refer","relation[i#1131l,j#1132]","releases.","remind","requir","resolv","return","root","run","runtim","safe","safe.","safety!","safety.","save","scala","scala.","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala>","schema","second,","see","select","select()","separately,","serial","serv","set","shapeless.tag.tagged[string(\"x\")]","show","simpl","simplist","slow","small","solut","solv","spark","spark'","spark.","spark.createdataset(","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark:","sparksess","standard","statement","statement).","store","string)","string,","string]","struct","subset","suffici","support","symbol","syntax","syntax.","take","thing","this.","time","time.","time:","togeth","tri","true,","tutori","two","type","type.","typedcolumn","typeddataset","typeddataset.","typeddataset.create(ds)","typeddataset.create(seq(mydate(new","typeddatset","unabl","unfortunately,","us","val","valu","value#1165l]","veri","view","want","way","well","without","work","w|","x","x:","|","|100|","|value|"],"TypedEncoder.html":["\"daterange\"","\"java.util.date\",","\"s\")","\"s\"))))","\"s\",","(a","(and","(class:","...","//","2.0)","242",":29:",":31:","=","[i:","^","annoy","approach","around","b:","bar","bar(1.1,","bar(d:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","behav","besid","call","care","case","class","class:","classes.","code","compil","construct","coupl","current","custom","data","data.","dataset","dataset?.","dataset[daterange]","daterange(s:","decod","defin","deriv","derived,","detect","different,","double,","ds.collect()","ds:","e:","elid","encod","encoder.","encoder:","encoders,","ensur","error","error:","exampl","example,","exist","expected:","extend","fail","field","find","follow","foo","foo(i:","foodate(i:","found","frameless","frameless.job$$anon$4@208e2282","frameless.job[seq[foo]]","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless:","gener","goe","hierarchi","ident","implicit","implicitli","import","inabl","int,","intern","introduc","issues.","it'","java.lang.unsupportedoperationexception:","java.util.d","java.util.date)","java.util.date)))","java.util.date))))","java.util.date,","jvm","lead","limit","manipul","mechan","method","more","name:","new","non","note","object","of)","onc","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:71)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$10.apply(scalareflection.scala:607)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$10.apply(scalareflection.scala:619)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:607)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:625)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:438)","org.apache.spark.sql.dataset","org.apache.spark.sql.encoders$.product(encoders.scala:275)","org.apache.spark.sql.lowprioritysqlimplicits$class.newproductencoder(sqlimplicits.scala:233)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:33)","overflow","paramet","pass","performances.","prove","question","recurs","reflect","represent","res2:","resolut","root","run","runtim","s:","same","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala>","scalareflect","schema.","see","shapeless","shown","situat","solv","spark","spark.implicits._","spark:","sqlcontext.createdataset(seq(daterange(new","stack","standard","store","string)","string,","struct]","summari","support","t:","take","thought","time,","time.","time:","trace,","tri","type","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeencod","types.","us","val","valu","vanilla","won't","work"],"Injection.html":["$anon$1@2b4ee43","//","09:21:38","1","18","2","2017))","3",":24:",":32:","=","=>","[age:","^","a):","again","anoth","apply(a:","apply(d:","available,","b","b):","b.","b]","bigint]","birthday:","can't,","case","class","class:","compil","creat","custom","d.gettime()","datetolonginject","datetolonginjection:","def","defin","definit","encod","encoder:","error.","error:","exampl","extend","family:","femal","find","frameless._","frameless.injection$$anon$1@5a548922","frameless.injection$$anon$1@62c73008","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.typeddataset[person]","frameless.typedencoder[person]","function:","gender","gender)","gender:","gendertoint:","implicit","import","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","instanc","int,","int]","invert(b:","invert(l:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date)","java.util.date))","java.util.date).gettime(),","java.util.date):","java.util.date.","less","let","let'","list(person(42,male))","list(person(42,w","long","long)))","long):","long:","long]","look","male","male))","more","new","now","object","oct","on","paramet","pdt","peopl","people:","person","person(age:","persond","personds:","precis","seal","seq(person(42,","seq[person]","serializ","simpl","trait","tri","type","type,","typeclass:","typeddataset,","typeddataset.create(people)","typeddataset:","typedencod","us","val","valu","verbos","{","}","})","},"],"Job.html":["(a","(sample:","//","1","20%","20)","=","=>","[_1:","abil","above)","above,","allow","along","annotate/nam","applic","be","block","calcul","call","captur","cat","cats.effect.sync","collect","compar","complex","compos","composit","comprehens","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","constructor","count","countandtakejob","data","def","default","description.","differ","driver","ds","ds:","easier","effect","effects.","element","elements:","exactli","exampl","example,","execut","expens","explicit","explicitli","f[_]","f[a]","f[a],","few","finaljob","finaljob.","finaljob:","first","frameless.","frameless.job","frameless.job$$anon$2@6ef768bf","frameless.job[int]","frameless.job[seq[int]])frameless.job[int]","frameless.syntax._","frameless.typeddataset[int]","functions:","further","group","have","help","id","implement","implicitli","import","inform","instanc","instance.","int","int]","issues.","job","job[a]","job[int]","job[seq[int]]):","jobs.","lazi","lazili","lazy,","lazy.","make","mention","min\").","module,","monad","more","new","non","now","obviou","open","oper","order","part","pass","perform","place","predict","program","programm","provid","repres","requir","res2:","result","return","run","run()","sample.map(_.min)","say,","see","sequenc","serv","sever","show","showcas","size","spark","spark.","sparkdelay","sparkdelay[f[_]]","sparksession.","specifi","strict","such","support","suspend","suspens","thunk","toy","track","track,","transform","type","typeclass","typeclass,","typeddataset","typeddataset.create(1","ui","us","user","val","value,","via","withdescription(\"sampl","withgroupid(\"samplingjob\").","{"],"Cats.html":["\"another\")))","\"string\"),","\"task2\"","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(1,","(1,2,3)","(10,9,9)","(2,","(8,","(8,2,3)","(and","(chris,map(0","(john,map(0","(sam,map(0","(semigroup)","(seq[(int,","(wrappedarray((1,string)),2)",")","//","1","1)","1))","1)),","1),","1,","10))","10,","100)","11))","12)","12,","15)))","2","2)","2))","2)),","2,","20)","20,","3)","3))","3,","32,","4))","4)),","4,","5,","6,",":45",":46",":48",":50","::","=",">","[_1:","_2:","abil","above.","abstract","action","action[(seq[(int,","action[t]","aggreg","algebra","alia","alias","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","anna","api","arbitrari","arity.","array((joe,map(0","array[(username,","assum","avg,","be","below","block","capabl","captur","cat","cats.data.readert","cats.effect.implicits._","cats.effect.io","cats.effect.sync[f].","cats.implicit","cats.implicits._","cats.mtl.implicits._","cats:","class","collect","column","combin","common","complex","comput","constructor","conveni","data","data.","data:","dataset","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","default","defin","delay","descript","description:","differ","effect","effect:","effects.","element","enhanc","enrich","etc.","exampl","example,","example:","execut","exist","f[_]","f[_],","fanci","first","follow","frameless","frameless.cats.implicits.","frameless.cats.implicits._","frameless.cats.implicits._.","frameless.cats.outer._","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[(int,","frameless:","full","general).","given","group","implicit","implicits.scala:18","implicits.scala:43","import","instanc","int","int)]","int,","integr","io","job,","joe","join","kernel","key","key.","keys.","larg","layer","lazy.","leverag","library:","local","long)","long)]","machineri","main","makerdd","map(\"task1\"","map(\"task3\"","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[24]","mapvalu","max,","meaning","method","min,","modifi","module,","monad","more","mtl","namely,","need","nil","nil)","normal","note","noth","now,","offer","on","oper","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","outer","over","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","pair","parallelcollectionrdd[14]","parallelcollectionrdd[15]","parallelcollectionrdd[17]","parallelcollectionrdd[19]","parallelcollectionrdd[20]","part","plain","pre","predicates.","previous","println(data.cmax)","println(data.cmin)","println(data.csum)","program,","properli","provid","r","rdd","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","readert","readert[io,","reducebykey","repres","request","res10:","res11:","res13:","res14:","res5:","res6:","result","result.run(spark).unsaferunsync()","result:","resultwithdescription.run(spark).unsaferunsync()","resultwithdescription:","run","run:","same","sampl","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala.collection.immutable.map[string,int])]","scala.collection.map[string,scala.collection.immutable.map[string,int]]","scala.collection.map[user,transactioncount]","section","semigroup","set","show","shuffledrdd[16]","shuffledrdd[18]","simplifi","sort","spark","sparkdelay","sparkdelay[f].","sparksess","sparksession,","sparksession.","stack","stack.","stack:","string","string)]","string)],","string]","suppli","suspend","suspended.","suspens","syntax","t]","task","task2","task3","thread","timeseri","timeseries)]","togeth","together.","totalperus","totalperuser.collectasmap","totalperuser:","transactioncount","transactioncount)]","tupl","two","type","type.","typeclass","typedd","typeddataset","typeddataset.create(seq((1,","typedds:","us","user","user'","usernam","util","val","valu","variabl","way","work","work,","wrap","yet.","{","|+|"],"TypedML.html":["//","1,","1.0","2))","2,","2.0","3)","=",">","[1.0,2.0,3.0]","[_1:","_2:","algebra","api","array(1,","begin","companion","currently,","data","defin","deriv","encod","eventu","frameless","frameless.ml._","frameless.typeddataset","frameless.typeddataset[(string,","goal","hood,","implicit","import","instanc","linear","matrices.dense(2,","matrix","matrix))","matrix:","matrix]","matrixd","matrixds:","ml","ml'","modul","more","object.","org.apache.spark.ml.linalg._","org.apache.spark.ml.linalg.matrix","org.apache.spark.ml.linalg.matrix)]","org.apache.spark.ml.linalg.matrix:","org.apache.spark.ml.linalg.matrixudt.","org.apache.spark.ml.linalg.vector","org.apache.spark.ml.linalg.vector)]","org.apache.spark.ml.linalg.vectorudt","org.apache.spark.sql.types.userdefinedtype[a]","possibl","provid","spark","spark.","string,","strongli","support","thank","type","typeddataset","typeddataset.create(seq(\"label\"","typedencod","typedencoder[a]","types.","under","us","val","vector","vector))","vector:","vector]","vectord","vectords:","vectors.dense(1,","veri"],"TypedDataFrame.html":["\"dummy\"","\"unique\"","').map(r","'_4)","'q',","'s)","'x',","'z'))","'z'.","(((((((((","(implicit","(phonebooktf:",")",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","//","1.6","1.6+,","1.6,","11","2.10,","2.11","2.11,","22.",":",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","=>","???","addit","address","address,","address:","alphabet:","alternatively,","amount","api","approach","approxim","ariti","avail","away:","b:","bar(i:","be","bestneighborhood","boolean","boolean)","boolean):","boolean)]","boolean,","both","bring","c:","call","case","catch","caus","citi","citymapentry(","citymaptf:","class","column","columns.","come","common","commonli","compar","compat","compil","complet","comput","concept:","consid","consist","contain","conveni","correct","cough","count:","d:","data,","datafram","dataframe,","dataframes,","dataset","def","defin","definit","deprec","design","develop","differ","directli","dive","documented.","domain","done","doubl","double,","due","each","earli","element","enough","ensur","essenti","everyth","exampl","example:","except","execut","exist","expect","f","f.neighborhood))","f.residents.split('","fact","family(residents:","field","filter(conditionexpr:","first","flat","focu","follow","foo(s:","frameless","frameless.","frameless.typeddatafram","frameless:","function","further","futur","get","go","goal","goe","handl","have","here","hold","however,","i:","ident","import","improv","inform","instead","int)","int,","interest","intermedi","introduc","introduct","j:","job","jobs.","join","join1(tf1:","join2(tf1:","joins,","keep","languag","less","let","let'","letter","level","leverag","librari","like,","limit","limitations.","line","long)","long)])","look","main","manag","manipul","manner.","map","mirror","mistak","model","moder","more","much","name","name.exists(set('x',","names,","natur","need","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","nlplib","nlplib.uniquename(p.name)","now","number,","object","obtain","ontypeddataframe.","onward.","org.apache.spark.sql.datafram","org.apache.spark.sql.sqlcontext","p","packag","pair","person(name:","person(r,","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","point,","possibl","process","product.","proof","provid","public","readability.","readabl","reasons,","refer","referenc","represent","residents:","result","rethought","return","right","sadly,","safe","safety.","scala","schema","schema.","second","see","see,","seem","select","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","shadow","shapeless.hlist","signatures:","similar","simplifi","singl","spark","spark'","spark,","sqlcontext):","stage","still","store","string","string):","string)]","string)])","string,","suppos","syntax","syntaxes,","system","systems,","tabl","table,","tables:","target","tdataframe[schema","tdataframe[schema]","techniqu","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","time.","track","troubl","tuple23","two","type","type,","type.","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry]","typeddataframe[citymapentry])","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","types:","typo,","uniqu","uniquename(name:","us","user","valu","vanilla","variou","veri","version","way","well,","won't","work","zero.","{","}"]},"length":9},"tokenStore":{"root":{"0":{"9":{"docs":{},":":{"2":{"1":{"docs":{},":":{"3":{"8":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{},".":{"1":{"3":{"docs":{},".":{"1":{"3":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"docs":{}},"docs":{}}},"docs":{}},"9":{"docs":{},".":{"docs":{},"x":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}},"docs":{}}},"1":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}},"docs":{}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"i":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"8":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0111731843575419}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008379888268156424},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},".":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"6":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"+":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"docs":{}}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"1":{"7":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"docs":{}},"docs":{},"%":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"4":{"0":{"9":{"docs":{},".":{"6":{"3":{"8":{"5":{"5":{"4":{"2":{"1":{"6":{"8":{"6":{"7":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"2":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"9":{"5":{"5":{"docs":{},".":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006905210295040804},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},".":{"docs":{},"x":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"1":{"0":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{},"x":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"docs":{}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"4":{"3":{"6":{"2":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"4":{"3":{"4":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"9":{"1":{"docs":{},".":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"4":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"6":{"8":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"7":{"4":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"7":{"8":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"docs":{}},"docs":{}},"8":{"3":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{},"\"":{"0":{"docs":{},".":{"3":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"docs":{}}},"docs":{}}},"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},"q":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"w":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"y":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"2":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"docs":{}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"%":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}},"%":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}}},"(":{"1":{"0":{"docs":{},",":{"9":{"docs":{},",":{"9":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}}},"docs":{}}},"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"2":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"8":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"y":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}},"t":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"#":{"1":{"1":{"3":{"1":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"1":{"1":{"3":{"1":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}},"e":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},"q":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"b":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"1":{"6":{"6":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"u":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"docs":{}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{}}}}}}}}}}},"\"":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}}}}}}},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687}}}}},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{}}}}}}}}}},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}},"+":{"1":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0696798493408663},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.04190260475651189}},"+":{"docs":{},"=":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"=":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"=":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.03327055869428751},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.013590033975084938},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.024615384615384615},"Injection.html":{"ref":"Injection.html","tf":0.06329113924050633},"Job.html":{"ref":"Job.html","tf":0.029411764705882353},"Cats.html":{"ref":"Cats.html","tf":0.04329608938547486},"TypedML.html":{"ref":"TypedML.html","tf":0.06015037593984962},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.016605166051660517}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.011325028312570781}},"=":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006795016987542469}}}},">":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}},">":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.055865921787709494},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}},"=":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"a":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"e":{"docs":{},"l":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"p":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"d":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003138731952291274}},"s":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"3":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"docs":{},"(":{"docs":{},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"[":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529}}}}}},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"4":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}},"b":{"docs":{},"o":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"i":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"l":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"l":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"g":{"docs":{},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"n":{"docs":{},"o":{"docs":{},"y":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"t":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"b":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"docs":{}}},"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"s":{"docs":{},"#":{"5":{"6":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006905210295040804},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"(":{"1":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"docs":{}},"docs":{}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007532956685499058},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0056625141562853904},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.021538461538461538},"Injection.html":{"ref":"Injection.html","tf":0.04113924050632911},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01845018450184502}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.017543859649122806},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":3.350093109869646}},"s":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},".":{"docs":{},"e":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"[":{"docs":{},"f":{"docs":{},"]":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}},"o":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}},"m":{"docs":{},"t":{"docs":{},"l":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"l":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"r":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"u":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005021971123666039},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.007927519818799546},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012915129151291513}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.502265005662514},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003138731952291274},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.007927519818799546},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012307692307692308},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"x":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}}}}}},"o":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351783517835174}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"o":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"o":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Injection.html":{"ref":"Injection.html","tf":2.5126582278481013}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":2.5031645569620253}},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003138731952291274},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"1":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"3":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"4":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.011299435028248588},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010192525481313703},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.033846153846153845},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.02214022140221402}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.021929824561403508},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.509060022650057},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"\"":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"?":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012915129151291513}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}},"y":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"f":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014760147601476014}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005649717514124294},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.03481012658227848},"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018461538461538463},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005021971123666039},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"e":{"docs":{},"s":{"docs":{},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}},"_":{"docs":{},".":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.021538461538461538},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"u":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.013157894736842105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006795016987542469},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3548717948717948},"Injection.html":{"ref":"Injection.html","tf":2.5126582278481013},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"s":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"t":{"docs":{},"i":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"i":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"s":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0056625141562853904},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"u":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"i":{"docs":{},",":{"1":{"0":{"docs":{},")":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}},"docs":{}},"docs":{}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.008379888268156424}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.333961079723791}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005649717514124294}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}},"a":{"docs":{},"l":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.007927519818799546},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},"c":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.039473684210526314},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3425641025641024},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}}}}}}}}}}}}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"5":{"docs":{},"a":{"5":{"4":{"8":{"9":{"2":{"2":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"6":{"2":{"docs":{},"c":{"7":{"3":{"0":{"0":{"8":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"2":{"docs":{},"@":{"6":{"docs":{},"e":{"docs":{},"f":{"7":{"6":{"8":{"docs":{},"b":{"docs":{},"f":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"docs":{}},"docs":{}},"docs":{}}}},"docs":{}}},"4":{"docs":{},"@":{"2":{"0":{"8":{"docs":{},"e":{"2":{"2":{"8":{"2":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},"_":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}}},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}}}}}}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"s":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"l":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"c":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006795016987542469}}}},"x":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"[":{"docs":{},"_":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"a":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"l":{"docs":{},")":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015822784810126583}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}}},"t":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"8":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},"docs":{}}},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"b":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}},"o":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"a":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"h":{"docs":{},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"l":{"docs":{},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"o":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"v":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"s":{"docs":{},"/":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}},"docs":{}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012307692307692308},"Injection.html":{"ref":"Injection.html","tf":0.015822784810126583},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"docs":{}},"4":{"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{}},"docs":{}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007532956685499058},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010192525481313703},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.015384615384615385},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.03212290502793296},"TypedML.html":{"ref":"TypedML.html","tf":0.045112781954887216},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015822784810126583}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"Injection.html":{"ref":"Injection.html","tf":2.5031645569620253}}},"(":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},"n":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005021971123666039},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"t":{"docs":{"./":{"ref":"./","tf":10},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"g":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"[":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"l":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"f":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"t":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"o":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"j":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"y":{"docs":{},"r":{"docs":{},"s":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"Job.html":{"ref":"Job.html","tf":10.004201680672269}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"i":{"docs":{},"n":{"1":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}}}}},"2":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01107011070110701}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"l":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.015384615384615385}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"v":{"docs":{},"m":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"e":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"s":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}}}}},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.017543859649122806}}}}}},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}},"w":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"docs":{}},"docs":{}}}}}}}}}}},"f":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"a":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}},"u":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"o":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"a":{"docs":{},"z":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"y":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"r":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"8":{"2":{"docs":{},".":{"5":{"9":{"7":{"0":{"5":{"4":{"8":{"8":{"6":{"2":{"1":{"1":{"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"m":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"r":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"Job.html":{"ref":"Job.html","tf":0.01680672268907563}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006983240223463687}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"2":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"docs":{}}}}}}}}}}},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.022556390977443608}},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}}}},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.008379888268156424}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}}},"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}}}},"3":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"docs":{}}}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"2":{"4":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},"n":{"docs":{},"i":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"e":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"x":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"l":{"docs":{"./":{"ref":"./","tf":0.013157894736842105},"TypedML.html":{"ref":"TypedML.html","tf":2.537593984962406}},"'":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"e":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.013157894736842105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007532956685499058},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"n":{"docs":{},"a":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}}}}}},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"u":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},"e":{"docs":{},"(":{"docs":{},"j":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018461538461538463},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}},"x":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"t":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"h":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003138731952291274},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529}}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"v":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}}}}}}}}}}}},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},"(":{"1":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},",":{"4":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"c":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.333961079723791}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"Cats.html":{"ref":"Cats.html","tf":0.009776536312849162}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"n":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}}}}}}}}}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.009060022650056626}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"$":{"2":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"8":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"6":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"1":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"9":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"$":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"1":{"0":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"0":{"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"1":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"0":{"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"2":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"3":{"8":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},"$":{"docs":{},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"$":{"docs":{},"$":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"7":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"1":{"5":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"2":{"1":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"6":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"7":{"0":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"$":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"{":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},".":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"g":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},")":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"u":{"docs":{},"d":{"docs":{},"t":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}},")":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"u":{"docs":{},"d":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"j":{"docs":{},"#":{"1":{"1":{"6":{"3":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232},"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"f":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.017543859649122806},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003138731952291274}},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"o":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351783517835174}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212},"TypedML.html":{"ref":"TypedML.html","tf":0.022556390977443608},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529}},"#":{"5":{"5":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}},"/":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003766478342749529}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"b":{"docs":{},"y":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}}}}}}}}},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"3":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.008771929824561403}}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"4":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"5":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"7":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"9":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}},"2":{"0":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"i":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01245753114382786}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"i":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"s":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}},"(":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519}},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}},"i":{"docs":{},"v":{"docs":{},"o":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006795016987542469}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"t":{"docs":{},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0056625141562853904}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"c":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"d":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"d":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"Cats.html":{"ref":"Cats.html","tf":3.3375232774674113}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"i":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"s":{"1":{"0":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"1":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"3":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"4":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"2":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"5":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"a":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0056625141562853904}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"[":{"docs":{},"i":{"docs":{},"o":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"u":{"docs":{},"i":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"#":{"1":{"1":{"3":{"1":{"docs":{},"l":{"docs":{},",":{"docs":{},"j":{"docs":{},"#":{"1":{"1":{"3":{"2":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003138731952291274}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}},"o":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"m":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"p":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"y":{"docs":{},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"d":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.017543859649122806}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"5":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"9":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},">":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"6":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"8":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}},"docs":{}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"y":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}},"z":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.02631578947368421},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.013590033975084938},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009230769230769232},"Job.html":{"ref":"Job.html","tf":0.03361344537815126},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedML.html":{"ref":"TypedML.html","tf":2.5225563909774436},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.01845018450184502}},"'":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5045300113250284},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},")":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"[":{"docs":{},"*":{"docs":{},"]":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"[":{"docs":{},"f":{"docs":{},"[":{"docs":{},"_":{"docs":{},"]":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"]":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}},"g":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}},",":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095}}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.015065913370998116},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014760147601476014}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.008771929824561403},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"l":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"e":{"docs":{},"#":{"5":{"4":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006905210295040804}}}}}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"m":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"c":{"docs":{},"h":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"[":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.012605042016806723}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"i":{"docs":{},"z":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0056625141562853904},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.021929824561403508},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.010043942247332079},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01925254813137033},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3456410256410254},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.0223463687150838},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.027675276752767528}},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.34440344403444}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"p":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.013157894736842105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005021971123666039},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.503397508493771},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedML.html":{"ref":"TypedML.html","tf":2.5225563909774436}},":":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3352165725047076},"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}},"docs":{}}}}}}}}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"docs":{}},"\"":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519}}}}}}}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"[":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}},"u":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154}}}}}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"s":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedML.html":{"ref":"TypedML.html","tf":0.022556390977443608}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"a":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.013157894736842105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012307692307692308}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"h":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"a":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}}}}},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}}}},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018832391713747645},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}},"p":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"e":{"2":{"3":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"docs":{}},"docs":{}}}}},"w":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"s":{"docs":{},"k":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}},"f":{"1":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"j":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"2":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"j":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}},"i":{"docs":{},"t":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}}}}}}}}},"p":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},",":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{"./":{"ref":"./","tf":0.03070175438596491},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005021971123666039},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006795016987542469},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"Cats.html":{"ref":"Cats.html","tf":3.3417132216014895},"TypedML.html":{"ref":"TypedML.html","tf":2.5225563909774436},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.00922509225092251}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"'":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}}}}}}},"d":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.01820464532328939},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0056625141562853904},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018461538461538463},"Injection.html":{"ref":"Injection.html","tf":0.03481012658227848},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.015363128491620111},"TypedML.html":{"ref":"TypedML.html","tf":0.03007518796992481}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Cats.html":{"ref":"Cats.html","tf":0.00558659217877095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},"e":{"docs":{},"#":{"1":{"1":{"6":{"5":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"o":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.022556390977443608}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}}},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"docs":{}}}}}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"a":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005021971123666039},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},"y":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005535055350553505}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"h":{"docs":{},"y":{"docs":{},"?":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0043859649122807015},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"(":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"'":{"docs":{},"`":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"x":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"_":{"4":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"q":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"z":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}},"*":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006277463904582548},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"_":{"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}},"docs":{}}}}}}},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},"docs":{}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}}}}}}}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.12303829252981795},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.08493771234428087},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03076923076923077},"Injection.html":{"ref":"Injection.html","tf":0.06645569620253164},"Job.html":{"ref":"Job.html","tf":0.025210084033613446},"Cats.html":{"ref":"Cats.html","tf":0.04748603351955307},"TypedML.html":{"ref":"TypedML.html","tf":0.06766917293233082},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}},":":{"2":{"0":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"5":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"9":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"docs":{}},"3":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}}},"2":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"4":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}},"docs":{}},"4":{"5":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"6":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"8":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}},"docs":{}},"5":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475}}},"docs":{}},"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344},"Cats.html":{"ref":"Cats.html","tf":0.025139664804469275}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036900369003690036}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"[":{"1":{"docs":{},".":{"0":{"docs":{},",":{"2":{"docs":{},".":{"0":{"docs":{},",":{"3":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.007518796992481203}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{},".":{"docs":{},".":{"1":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}},"docs":{}},"docs":{}}}}},"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}},"x":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"_":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}}}},"docs":{}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"#":{"5":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006905210295040804}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012554927809165098}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"4":{"3":{"6":{"2":{"9":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}}}}},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313}}}},"i":{"docs":{},"#":{"1":{"1":{"3":{"1":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},",":{"docs":{},"j":{"docs":{},"#":{"1":{"1":{"3":{"2":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033975084937712344}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.003076923076923077}}},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"[":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}}}}}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}},"^":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004394224733207784},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004530011325028313},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006153846153846154},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}},"_":{"1":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"#":{"1":{"2":{"3":{"6":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196},"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375},"TypedML.html":{"ref":"TypedML.html","tf":0.015037593984962405}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}}}},"docs":{}},"|":{"1":{"0":{"0":{"0":{"docs":{},"|":{"1":{"0":{"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"docs":{}},"docs":{}},"2":{"7":{"6":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"6":{"2":{"docs":{},".":{"8":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.015693659761456372},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.009060022650056626}},"[":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"4":{"5":{"docs":{},",":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"8":{"3":{"docs":{},",":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"2":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"7":{"4":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"3":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"1":{"0":{"0":{"docs":{},",":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"2":{"5":{"docs":{},",":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"5":{"0":{"docs":{},",":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006277463904582549}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0025109855618330196}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}},"+":{"docs":{},"|":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.004189944134078212}}}}},"$":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"1":{"4":{"docs":{},".":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"2":{"docs":{},"b":{"4":{"docs":{},"e":{"docs":{},"e":{"4":{"3":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{}},"docs":{}}}},"docs":{}}},"docs":{}}},"docs":{}}}}}}},"&":{"docs":{},"&":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0022650056625141564}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0011325028312570782}}}},"{":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002793296089385475},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}}},"}":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.007380073800738007}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"y":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013966480446927375}}}}}},"?":{"docs":{},"?":{"docs":{},"?":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018450184501845018}}}}}}}},"length":2516},"corpusTokens":["\"0.3.0\"","\"another\")))","\"daterange\"","\"dummy\"","\"e\")","\"false\")","\"frameless","\"java.util.date\",","\"jday\")","\"mydate\"","\"org.typelevel\"","\"paris\")","\"q\")","\"s\")","\"s\"))))","\"s\",","\"string\"),","\"task2\"","\"unique\"","\"w\")","$anon$1@2b4ee43","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","%","%%","&&","').map(r","'_4)","'`citi`'","'`x`'","'name),","'population)","'price),","'project","'q',","'s)","'x',","'z'))","'z'.","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(((((((((","(1,","(1,2,3)","(10,9,9)","(2,","(8,","(8,2,3)","(a","(a)","(and","(automated)","(b)","(case","(chris,map(0","(class:","(e.g.","(enjoy","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(i#1131l","(implicit","(in","(includ","(int,","(isnotnull(i#1131l)","(john,map(0","(look","(lyon,166500.0))","(manual)","(name:","(paris,333333.3333333333),","(peopl","(phonebooktf:","(sam,map(0","(sample:","(see","(semigroup)","(seq[(int,","(string,","(support","(the","(thumb","(u:","(up","(which","(with","(wrappedarray((1,string)),2)",")",").as[aptpricecity].show().run",").as[stats].show().run()",").explain()",").select(",").show().run()","*","*deserializetoobject","*filescan","*filter","*mapel","*project","*serializefromobject","+","++=","+1,","+=",",","...",".appli",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","/","//","0.13.13:","0.9.x)","09:21:38","1","1)","1))","1)),","1),","1,","1.0","1.6","1.6+,","1.6,","10","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10,","100)","100,","10000.0,","102|","10|","11","11))","12)","12,","133000.0,","133000.0|","15)))","18","1|","2","2)","2))","2)),","2),","2).as[updatedsurface]","2).show().run()","2,","2.0","2.0)","2.0,","2.0.x)","2.10,","2.11","2.11,","2.11.x.","20%","20)","20,","200000.0,","200000.0|","2017))","22.","2229621),","2229621|","2409.6385542168673,","242","25,","250000.0,","250000.0|","250|","25|[paris,","27|","2955.5555555555557,","3","3)","3))","3),","3,","300000.0,","300000.0|","32,","325000.0,","325000.0|","343629)","343629|","4","4))","4)),","4,","434","4391.891891891892)","4391.891891891892|","45,","4500.0,","450000.0,","450000.0|","450|","454","47|","5,","50,","500715),","500715|","500|","52|","6,","6833.333333333333|","74,","740|","76|","778","83,","830|","85|",":",":20:",":24:",":25:",":27:",":28:",":29:",":31:",":32:",":33:",":34:",":36:",":45",":46",":48",":50","::",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","==","===","=>",">",">=","???","['citi]","['x]","[1...10]).","[1.0,2.0,3.0]","[],","[_1:","[age:","[city#53,","[city,","[city:","[i#1131l","[i#1131l,j#1132]","[i#1131l]","[i,","[i:","[input[0,","[isnotnull(i),","[lyon,500715]|","[nice,343629]|","[out](other:","[ratio:","^","_1#1236l]","_1|","_2:","_2|","a):","abil","abov","above)","above,","above.","abstract","access","achiev","act","action","action[(seq[(int,","action[t]","actual","ad","add","addit","address","address,","address:","adelbertc","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","against","agg()","agg(avg(aptds('price))).","aggreg","aggregated,","agree.","algebra","alia","alias","align.","allcities:","allcities|","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","allowed,","allowed.","along","alphabet:","alternatively,","alternatives:","amount","and/or","anna","annotate/nam","annoy","anoth","apach","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartmentdetail","apartmentdetails(city:","apartmentdetails?","api","api:","appear","appli","applic","applications.","apply(a:","apply(d:","approach","approxim","aptd","aptds('price)","aptds('price)))","aptds('price),","aptds('surface))","aptds('surface)).as[apartmentdetails]","aptds('surface),","aptds.","aptds.agg(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)).as[updatedsurface]","apttypedds('city),","apttypedds('city).cast[double]","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.join(citiinfotypedds,","apttypedds.makeudf(pricemodifier)","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds2","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","are:","area","argument","arguments)","ariti","arity.","around","array((joe,map(0","array(1,","array[(username,","as:","as[bedroomstats]","as[long]","as[t]","associ","assum","at[long]","avail","available,","available.","averag","avg(aptds('price)),","avg(aptds('surface)),","avg,","avgprice:","avgpricebeds1:","avgpricebeds2:","avgpricebeds3:","avgpricebeds4:","avgprice|","avgsurface:","avgsurface|minsurface|","avoid","away:","b","b):","b.","b:","b]","bar","bar(1)))","bar(1.1,","bar(d:","bar(i:","bar)","bardate(1.1,","bardate(d:","bardate)","base","batched:","be","bedroom","bedrooms#56]","bedrooms.","bedrooms:","bedrooms];;","bedroomstat","bedroomstats(","bedroomstats(lyon,some(133000.0),some(200000.0),none,none)","bedroomstats(nice,none,none,some(325000.0),none)","bedroomstats(paris,some(250000.0),some(300000.0),some(450000.0),none)","bedroomstats.collect().run().foreach(println)","bedroomstats.show().run()","bedroomstats:","before.","begin","behav","below","benefit","besid","bestneighborhood","better","between","bigint","bigint))","bigint,","bigint]","bind","birthday:","block","boolean","boolean)","boolean):","boolean)]","boolean)].","boolean,","bootstrap","both","break","bring","bug","build.sbt","built","bulletproof:","c:","calcul","call","can't","can't,","capabl","captur","care","case","case.","cast","cast(10","cast,","cat","catalyst","catalystcast.","catalystcast[string,","catch","cats\"","cats.data.readert","cats.effect.implicits._","cats.effect.io","cats.effect.sync","cats.effect.sync[f].","cats.implicit","cats.implicits._","cats.mtl.implicits._","cats:","caus","chang","channel","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name))","city:","cityinfo","cityinfo(city:","citymapentry(","citymaptf:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|avgpricebeds1|avgpricebeds2|avgpricebeds3|avgpricebeds4|","city|surface|","class","class:","classes)","classes.","clause.","clearli","closur","closures.","code","code.","collect","collectset(aptds('city))","column","column.","column:","columnar","columns,","columns.","columns:","combin","come","common","commonli","companion","compar","comparison,","compat","compil","compile.","compile:","compiles:","complet","complex","compos","composit","comprehens","compromis","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","concept","concept:","conduct","conf","consid","consist","consol","construct","constructor","contain","content","context","continu","contribut","contributor","conveni","correct","correct.","correctli","correspond","cough","count","count:","countandtakejob","coupl","creat","current","currently,","custom","customizable,","d.gettime()","d:","data","data,","data.","data:","datafram","dataframe,","dataframes,","dataset","dataset\"","dataset.","dataset:","dataset?.","dataset[daterange]","dataset[long].","datasets,","daterange(s:","datetolonginject","datetolonginjection:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","decod","def","default","defin","definit","delay","depend","deprec","deriv","derived,","descript","description.","description:","design","detail","detail.","detect","develop","differ","different,","directli","discuss","discussion.","disk","dive","divid","document","documented.","doesn't","domain","done","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","ds","ds.collect()","ds.filter($\"i\"","ds.filter(_.i","ds.show()","ds:","due","e:","each","earli","easi","easier","easili","effect","effect:","effects.","element","elements:","elid","encod","encoder.","encoder:","encoders,","enhanc","enough","enrich","ensur","entir","environ","equalto(i,10)],","error","error.","error:","essenti","etc)","etc.","eventu","everyth","evid","exactli","exampl","example,","example.","example:","except","execut","exist","expect","expected:","expens","explain","explan","explicit","explicitli","express","extend","extra","extrem","e|","f","f.neighborhood))","f.residents.split('","f[_]","f[_],","f[a]","f[a],","fact","fail","failure:","false]","familiar","family(residents:","family:","fanci","fd","fds('i)","fds('x)","fds.filter(","fds:","featur","femal","few","field","fields.","fields]","file","file.","filter","filter(conditionexpr:","filteredd","filteredds.explain()","filteredds.show()","filteredds:","finaljob","finaljob.","finaljob:","find","first","first,","five","flat","focu","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo(s:","foo,","foo.","foodate(i:","form","format","format:","found","frameless","frameless'","frameless.","frameless._","frameless.catalystcast[string,double]","frameless.catalystdivisible[double,out],","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.cats.implicits.","frameless.cats.implicits._","frameless.cats.implicits._.","frameless.cats.outer._","frameless.functions.aggregate._","frameless.implicits.widen._","frameless.injection$$anon$1@5a548922","frameless.injection$$anon$1@62c73008","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.job","frameless.job$$anon$2@6ef768bf","frameless.job$$anon$4@208e2282","frameless.job[int]","frameless.job[seq[foo]]","frameless.job[seq[int]])frameless.job[int]","frameless.ml._","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[apartment,double])(implicit","frameless.typeddatafram","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(int,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[bedroomstats]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[foo]","frameless.typeddataset[int]","frameless.typeddataset[person]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless.typedencoder[mydate]","frameless.typedencoder[out])frameless.typedcolumn[apartment,out]","frameless.typedencoder[person]","frameless:","framelessvers","framelessversion,","friend.","friendli","full","fulli","function","function:","functions:","further","futur","g8","gender","gender)","gender:","gendertoint:","gener","general).","generated.","get","giter8","github,","gitter)","give","given","go","goal","goal:","goe","great!","ground,","group","groupbi","groupby()","groupby(aptds('city)).","guard","handhold","handl","have","help","here","here.","here:","hierarchi","hold","hood,","however,","http://opensource.org/licenses/apach","i:","id","ident","if(nam","imario","imarios/frameless.g8","implement","implicit","implicitli","implicits.scala:18","implicits.scala:43","import","improv","inabl","incompat","inform","initi","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","inmemoryfileindex[file:/tmp/foo],","input","insid","instal","instanc","instance.","instances:","instanti","instead","int","int)","int).","int)]","int,","int.","int]","integr","interest","intermedi","intern","introduc","introduct","intuitively,","invert(b:","invert(l:","io","issues.","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date(system.currenttimemillis))))","java.util.date)","java.util.date))","java.util.date)))","java.util.date))))","java.util.date).gettime(),","java.util.date):","java.util.date,","java.util.date.","jeremyrsmith","job","job,","job[a]","job[int]","job[seq[int]]):","jobs.","joe","join","join1(tf1:","join2(tf1:","joins,","jvm","j|","kanterov","keep","kernel","key","key.","keys.","know","languag","larg","last","layer","lazi","lazili","lazy,","lazy.","lead","learning.","less","let","let'","letter","level","leverag","librari","library:","librarydepend","licens","lift","like,","limit","limitations.","line","linear","linux","list(","list(person(42,male))","list(person(42,w","load","local","localrel","location:","long","long)","long)))","long):","long)]","long)])","long,","long:","long]","look","lyon]|","lyon|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","mac","machineri","macro","made","main","maintain","make","makerdd","male","male))","manag","manipul","manner.","map","map(\"task1\"","map(\"task3\"","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[24]","mapvalu","materialize.","math","matrices.dense(2,","matrix","matrix))","matrix:","matrix]","matrixd","matrixds:","matter","max,","meaning","mechan","member","members.","mention","merg","method","method.","min\").","min(aptds('surface)),","min,","minimum","minsurface:","mirror","miss","missing,","misspel","mistak","ml","ml'","model","moder","modifi","modul","module,","modules:","monad","more","mtl","much","mydat","mydate(jday:","n","n:","name","name.exists(set('x',","name:","namely,","names,","natur","need","needed:","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","new","newinstance(class","next","next,","nice,","nice|","nice|325000.0|","nil","nil)","nlplib","nlplib.uniquename(p.name)","non","normal","not,","note","noth","notifi","now","now,","null|","number","number,","obj#1163:","obj#1164:","object","object.","obtain","obviou","oct","of)","offer","ok","olivierblanvillain","on","on(1,2,3,4).","onc","ontypeddataframe.","onward.","open","oper","operations:","optim","optimizer)","option","option.","option[double])","option[double],","order","org.apache.spark.ml.linalg._","org.apache.spark.ml.linalg.matrix","org.apache.spark.ml.linalg.matrix)]","org.apache.spark.ml.linalg.matrix:","org.apache.spark.ml.linalg.matrixudt.","org.apache.spark.ml.linalg.vector","org.apache.spark.ml.linalg.vector)]","org.apache.spark.ml.linalg.vectorudt","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:88)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:71)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$6.apply(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1$1.apply(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$transformexpressionsup$1.apply(queryplan.scala:268)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:289)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:268)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$10.apply(scalareflection.scala:607)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$10.apply(scalareflection.scala:619)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:607)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:625)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:438)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:70)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:289)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:127)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:187)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:288)","org.apache.spark.sql.datafram","org.apache.spark.sql.dataset","org.apache.spark.sql.dataset$.ofrows(dataset.scala:66)","org.apache.spark.sql.dataset.(dataset.scala:164)","org.apache.spark.sql.dataset.(dataset.scala:170)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2872)","org.apache.spark.sql.dataset.select(dataset.scala:1153)","org.apache.spark.sql.dataset.select(dataset.scala:1213)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:275)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:52)","org.apache.spark.sql.lowprioritysqlimplicits$class.newproductencoder(sqlimplicits.scala:233)","org.apache.spark.sql.sparksess","org.apache.spark.sql.sqlcontext","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:33)","org.apache.spark.sql.types.userdefinedtype[a]","org.apache.spark.{sparkconf,","os","outer","over","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","overflow","overload","overview","p","packag","pair","parallelcollectionrdd[14]","parallelcollectionrdd[15]","parallelcollectionrdd[17]","parallelcollectionrdd[19]","parallelcollectionrdd[20]","paramet","parquet","parquet,","part","partial","particular","partitionfilters:","pass","pdt","peopl","people:","per","perform","performance.","performances.","perhap","person","person(age:","person(name:","person(r,","persond","personds:","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","physic","pivot","pivot(aptds('bedrooms)).","pivot,","place","plain","plan","plan,","plan.","plan:","point,","popul","popular","population:","possibl","potenti","practic","pre","precis","predicates.","predict","prefer","preserv","previous","price","price#55,","price,","price/surfac","price:","price:double)","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.collect.run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","primit","println(data.cmax)","println(data.cmin)","println(data.csum)","problem","problem.","proce","process","product","product,","product.","program","program,","programm","project","project:","proof","properli","prove","provid","public","pull","pushedfilters:","queri","question","quick","q|","r","rais","ratio","ratio:","ratio|","rdd","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","read","readability.","readabl","readert","readert[io,","readi","readschema).","readschema:","reasons,","recurs","reducebykey","refer","referenc","reflect","relation[i#1131l,j#1132]","releases.","remind","repl\").set(\"spark.ui.enabled\",","repres","represent","request","requests)","requests.","requir","res10:","res11:","res13:","res14:","res17:","res2:","res5:","res6:","res7:","residents:","resolut","resolv","resolver.sonatyperepo(\"releases\")","result","result.run(spark).unsaferunsync()","result:","resultwithdescription.run(spark).unsaferunsync()","resultwithdescription:","rethought","retriev","return","right","right?","root","row","run","run()","run:","runtim","s:","sadly,","safe","safe,","safe.","safety!","safety,","safety.","same","sampl","sample.map(_.min)","save","say,","sbt","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala","scala.","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.immutable.map[string,int])]","scala.collection.map[string,scala.collection.immutable.map[string,int]]","scala.collection.map[user,transactioncount]","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala>","scalareflect","schema","schema.","seal","second","second,","secondari","section","see","see,","seem","select","select()","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","selectmany()","selectmany,","semigroup","separately,","seq(","seq(person(42,","seq[(string,","seq[double]","seq[person]","sequenc","serial","serializ","serv","set","sever","shadow","shapeless","shapeless.hlist","shapeless.tag.tagged[string(\"citi\")]","shapeless.tag.tagged[string(\"x\")]","shell","shorter","show","show()","showcas","shown","shuffledrdd[16]","shuffledrdd[18]","sign","signatur","signatures:","similar","similar)","simpl","simplifi","simplist","simply:","singl","situat","size","skip","slow","small","solut","solv","sort","spark","spark'","spark).","spark,","spark.","spark.createdataset(","spark.createdataset(apartments)","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark.sparkcontext.setloglevel(\"warn\")","spark.sqlcontext","spark:","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparkdelay","sparkdelay[f[_]]","sparkdelay[f].","sparksess","sparksession,","sparksession.","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","sqlcontext","sqlcontext):","sqlcontext.createdataset(seq(daterange(new","stack","stack.","stack:","stage","standard","start","stat","statement","statement).","stats(","still","store","strict","string","string)","string),updatedsurface]","string):","string)]","string)])","string)],","string,","string.","string]","strongli","struct","struct,","struct]","subset","such","suffici","suggests,","summari","suppli","support","suppos","surfac","surface#54,","surface,","surface,th","surface:","suspend","suspended.","suspens","symbol","syntax","syntax.","syntax:","syntaxes,","system","systems,","t","t:","t]","tabl","table,","tables:","take","target","task","task2","task3","tdataframe[schema","tdataframe[schema]","techniqu","tell","ten","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","thank","thing","this.","thought","thread","three","thunk","time","time,","time.","time:","timeseri","timeseries)]","togeth","together.","top","totalperus","totalperuser.collectasmap","totalperuser:","toy","trace):","trace,","track","track,","trait","transactioncount","transactioncount)]","transform","tri","troubl","true,","tupl","tuple23","tutori","two","type","type,","type.","type:","typeclass","typeclass,","typeclass:","typedcolumn","typedd","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry]","typeddataframe[citymapentry])","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","typeddataset","typeddataset,","typeddataset.","typeddataset.create(1","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset.create(ds)","typeddataset.create(people)","typeddataset.create(seq(\"label\"","typeddataset.create(seq((1,","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset.create(seq(mydate(new","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","typeddatset","typedds:","typedencod","typedencoder[a]","typeencod","typelevel","types,","types.","types:","typesaf","typesafeti","typo","typo,","u","udf","udf(aptds('city),","udf:","ui","unabl","under","unfortunately,","uniqu","uniquename(name:","unit:","unlik","unsaf","up","up,","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","user'","usernam","util","val","valid","valu","value#1165l]","value,","vanilla","variabl","variou","vector","vector))","vector:","vector[string])","vector]","vectord","vectords:","vectors.dense(1,","verbos","veri","version","versions.","via","view","want","way","well","well,","wherea","why?","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withdescription(\"sampl","withgroupid(\"samplingjob\").","without","won't","work","work,","worked,","wrap","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","w|","x","x:","yet.","zero.","{","|","|+|","|1000|102|","|100|","|276333.3333333333|62.833333333333336|","|4500.0|450000.0|","|6000.0|300000.0|","|[lyon,45,133000.0,1]|","|[lyon,83,200000.0,2]|","|[nice,74,325000.0,3]|","|[paris,100,450000...|[paris,2229621]|","|[paris,25,250000....|[paris,2229621]|","|[paris,50,300000....|[paris,2229621]|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|value|","}","})","},"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"Introduction","keywords":"","body":"Frameless\n\n\n\n\nFrameless is a proof-of-concept library for working with Spark using more expressive types.\nIt consists of the following modules:\n\ndataset for more strongly typed Datasets  (supports Spark 2.0.x)\ncats for using Spark with cats (supports Cats 0.9.x)\nml for a more strongly typed use of Spark ML based on dataset\n\nThe Frameless project and contributors support the\nTypelevel Code of Conduct and want all its\nassociated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning.\nDocumentation\n\nTypedDataset: Feature Overview\nComparing TypedDatasets with Spark's Datasets\nTyped Encoders in Frameless\nInjection: Creating Custom Encoders\nJob[A]\nUsing Cats with RDDs\nTypedDataset support for Spark ML\nProof of Concept: TypedDataFrame\n\nWhy?\nBenefits of using TypedDataset compared to the standard Spark Dataset API:\n\nTypesafe columns referencing and expressions\nCustomizable, typesafe encoders\nTypesafe casting and projections\nEnhanced type signature for some built-in functions\n\nQuick Start\nFrameless is compiled against Scala 2.11.x.\nNote that while Frameless is still getting off the ground, it is very possible that breaking changes will be\nmade for at least the next few versions.\nTo use Frameless in your project add the following in your build.sbt file as needed:\nresolvers += Resolver.sonatypeRepo(\"releases\")\n\nval framelessVersion = \"0.3.0\"\n\nlibraryDependencies ++= List(\n  \"org.typelevel\" %% \"frameless-cats\"      % framelessVersion,\n  \"org.typelevel\" %% \"frameless-dataset\"   % framelessVersion\n)\n\nAn easy way to bootstrap a Frameless sbt project:\n\nif you have Giter8 installed then simply:\n\ng8 imarios/frameless.g8\n\n\nwith sbt >= 0.13.13:\n\nsbt new imarios/frameless.g8\n\nTyping sbt console inside your project will bring up a shell with Frameless\nand all its dependencies loaded (including Spark).\nDevelopment\nWe require at least one sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers\n(people who can merge pull requests) are:\n\nadelbertc\nimarios\njeremyrsmith\nkanterov\nnon\nOlivierBlanvillain\n\nLicense\nCode is provided under the Apache 2.0 license available at http://opensource.org/licenses/Apache-2.0,\nas well as in the LICENSE file. This is the same license used as Spark.\n"},"FeatureOverview.html":{"url":"FeatureOverview.html","title":"TypedDataset: Feature Overview","keywords":"","body":"TypedDataset: Feature Overview\nThis tutorial introduces TypedDataset using a simple example.\nThe following imports are needed to make all code examples compile.\nimport org.apache.spark.{SparkConf, SparkContext}\nimport org.apache.spark.sql.SparkSession\nimport frameless.functions.aggregate._\nimport frameless.TypedDataset\n\nval conf = new SparkConf().setMaster(\"local[*]\").setAppName(\"frameless repl\").set(\"spark.ui.enabled\", \"false\")\nval spark = SparkSession.builder().config(conf).appName(\"REPL\").getOrCreate()\nimplicit val sqlContext = spark.sqlContext\nspark.sparkContext.setLogLevel(\"WARN\")\n\nimport spark.implicits._\n\nCreating TypedDataset instances\nWe start by defining a case class:\ncase class Apartment(city: String, surface: Int, price: Double, bedrooms: Int)\n\nAnd few Apartment instances:\nval apartments = Seq(\n  Apartment(\"Paris\", 50,  300000.0, 2),\n  Apartment(\"Paris\", 100, 450000.0, 3),\n  Apartment(\"Paris\", 25,  250000.0, 1),\n  Apartment(\"Lyon\",  83,  200000.0, 2),\n  Apartment(\"Lyon\",  45,  133000.0, 1),\n  Apartment(\"Nice\",  74,  325000.0, 3)\n)\n\nWe are now ready to instantiate a TypedDataset[Apartment]:\nval aptTypedDs = TypedDataset.create(apartments)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nWe can also create one from an existing Spark Dataset:\nval aptDs = spark.createDataset(apartments)\n// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval aptTypedDs = TypedDataset.create(aptDs)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nOr use the Frameless syntax:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval aptTypedDs2 = aptDs.typed\n// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nTypesafe column referencing\nThis is how we select a particular column from a TypedDataset:\nval cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))\n// cities: frameless.TypedDataset[String] = [_1: string]\n\nThis is completely type-safe, for instance suppose we misspell city as citi:\naptTypedDs.select(aptTypedDs('citi))\n// :28: error: No column Symbol with shapeless.tag.Tagged[String(\"citi\")] of type A in Apartment\n//        aptTypedDs.select(aptTypedDs('citi))\n//                                    ^\n\nThis gets raised at compile-time, whereas with the standard Dataset API the error appears at run-time (enjoy the stack trace):\naptDs.select('citi)\n// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [city, surface, price, bedrooms];;\n// 'Project ['citi]\n// +- LocalRelation [city#53, surface#54, price#55, bedrooms#56]\n// \n//   at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:88)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:85)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:70)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:288)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:279)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:289)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1$1.apply(QueryPlan.scala:293)\n//   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n//   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n//   at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)\n//   at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)\n//   at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n//   at scala.collection.AbstractTraversable.map(Traversable.scala:104)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:293)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$6.apply(QueryPlan.scala:298)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:187)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:298)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:268)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:85)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)\n//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)\n//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)\n//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:66)\n//   at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2872)\n//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1153)\n//   ... 434 elided\n\nselect() supports arbitrary column operations:\naptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()\n// +----+---+\n// |  _1| _2|\n// +----+---+\n// | 500| 52|\n// |1000|102|\n// | 250| 27|\n// | 830| 85|\n// | 450| 47|\n// | 740| 76|\n// +----+---+\n//\n\nNote that unlike the standard Spark API where some operations are lazy and some are not, TypedDatasets have all operations to be lazy. \nIn the above example, show() is lazy. It requires to apply run() for the show job to materialize.\nA more detailed explanation of Job is given here.\nNext we compute the price by surface unit:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// :27: error: overloaded method value / with alternatives:\n//   (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] \n//   [Out](other: frameless.TypedColumn[Apartment,Double])(implicit n: frameless.CatalystDivisible[Double,Out], implicit e: frameless.TypedEncoder[Out])frameless.TypedColumn[Apartment,Out]\n//  cannot be applied to (frameless.TypedColumn[Apartment,Int])\n//        val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n//                                                                      ^\n\nAs the error suggests, we can't divide a TypedColumn of Double by Int. \nFor safety, in Frameless only math operations between same types is allowed. \nThere are two ways to proceed here: \n(a) Explicitly cast Int to Double (manual)\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect().run()\n// res6: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\n(b) Perform the cast implicitly (automated)\nimport frameless.implicits.widen._\n// import frameless.implicits.widen._\n\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect.run()\n// res7: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\nLooks like it worked, but that cast seems unsafe right? Actually it is safe.\nLet's try to cast a TypedColumn of String to Double:\naptTypedDs('city).cast[Double]\n// :31: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]\n//        aptTypedDs('city).cast[Double]\n//                              ^\n\nThe compile-time error tells us that to perform the cast, an evidence \n(in the form of CatalystCast[String, Double]) must be available. \nSince casting from String to Double is not allowed, this results \nin a compilation error. \nCheck here \nfor the set of available CatalystCast.\nTypeSafe TypedDataset casting and projections\nWith select() the resulting TypedDataset is of type TypedDataset[TupleN[...]] (with N in [1...10]).\nFor example, if we select three columns with types String, Int, and Boolean the result will have type\nTypedDataset[(String, Int, Boolean)]. To select more than ten columns use the selectMany() method. \nSelect has better IDE support than the macro based selectMany, so prefer select() for the general case. \nWe often want to give more expressive types to the result of our computations.\nas[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long\nas the types in U and T align.\nWhen the cast is valid the expression compiles:\ncase class UpdatedSurface(city: String, surface: Int)\n// defined class UpdatedSurface\n\nval updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]\n// updated: frameless.TypedDataset[UpdatedSurface] = [city: string, surface: int]\n\nupdated.show(2).run()\n// +-----+-------+\n// | city|surface|\n// +-----+-------+\n// |Paris|     52|\n// |Paris|    102|\n// +-----+-------+\n// only showing top 2 rows\n//\n\nNext we try to cast a (String, String) to an UpdatedSurface (which has types String, Int).\nThe cast is not valid and the expression does not compile:\naptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// :33: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]\n//        aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n//                                                                  ^\n\nProjections\nWe often want to work with a subset of the fields in a dataset.\nProjections allows to easily select the fields we are interested\nwhile preserving their initial name and types for extra safety.\nHere is an example using the TypedDataset[Apartment] with an additional column:\nimport frameless.implicits.widen._\n// import frameless.implicits.widen._\n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\ncase class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)\n// defined class ApartmentDetails\n\nval aptWithRatio = aptds.select(aptds('city), aptds('price), aptds('surface), aptds('price) / aptds('surface)).as[ApartmentDetails]\n// aptWithRatio: frameless.TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]\n\nSuppose we only want to work with city and ratio:\ncase class CityInfo(city: String, ratio: Double)\n// defined class CityInfo\n\nval cityRatio = aptWithRatio.project[CityInfo]\n// cityRatio: frameless.TypedDataset[CityInfo] = [city: string, ratio: double]\n\ncityRatio.show(2).run()\n// +-----+------+\n// | city| ratio|\n// +-----+------+\n// |Paris|6000.0|\n// |Paris|4500.0|\n// +-----+------+\n// only showing top 2 rows\n//\n\nSuppose we only want to work with price and ratio:\ncase class PriceInfo(ratio: Double, price: Double)\n// defined class PriceInfo\n\nval priceInfo = aptWithRatio.project[PriceInfo]\n// priceInfo: frameless.TypedDataset[PriceInfo] = [ratio: double, price: double]\n\npriceInfo.show(2).run()\n// +------+--------+\n// | ratio|   price|\n// +------+--------+\n// |6000.0|300000.0|\n// |4500.0|450000.0|\n// +------+--------+\n// only showing top 2 rows\n//\n\nWe see that the order of the fields does not matter as long as the\nnames and the corresponding types agree. However, if we make a mistake in\nany of the names and/or their types, then we get a compilation error.\nSay we make a typo in a field name:\ncase class PriceInfo2(ratio: Double, pricEE: Double)\n\naptWithRatio.project[PriceInfo2]\n// :36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?\n//        aptWithRatio.project[PriceInfo2]\n//                            ^\n\nSay we make a mistake in the corresponding type:\ncase class PriceInfo3(ratio: Int, price: Double) // ratio should be Double\n\naptWithRatio.project[PriceInfo3]\n// :36: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?\n//        aptWithRatio.project[PriceInfo3]\n//                            ^\n\nUser Defined Functions\nFrameless supports lifting any Scala function (up to five arguments) to the\ncontext of a particular TypedDataset:\n// The function we want to use as UDF\nval priceModifier =\n    (name: String, price:Double) => if(name == \"Paris\") price * 2.0 else price\n// priceModifier: (String, Double) => Double = \n\nval udf = aptTypedDs.makeUDF(priceModifier)\n// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = \n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))\n// adjustedPrice: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\nadjustedPrice.show().run()\n// +-----+--------+\n// |   _1|      _2|\n// +-----+--------+\n// |Paris|600000.0|\n// |Paris|900000.0|\n// |Paris|500000.0|\n// | Lyon|200000.0|\n// | Lyon|133000.0|\n// | Nice|325000.0|\n// +-----+--------+\n//\n\nGroupBy and Aggregations\nLet's suppose we wanted to retrieve the average apartment price in each city\nval priceByCity = aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('price)))\n// priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\npriceByCity.collect().run()\n// res17: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))\n\nAgain if we try to aggregate a column that can't be aggregated, we get a compilation error\naptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))                                                        \n// :34: error: Cannot compute average of type String.\n//        aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))\n//                                                     ^\n\nNext, we combine select and groupBy to calculate the average price/surface ratio per city:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval cityPriceRatio =  aptds.select(aptds('city), aptds('price) / aptds('surface))\n// cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\ncityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()\n// +-----+------------------+\n// |   _1|                _2|\n// +-----+------------------+\n// | Nice| 4391.891891891892|\n// |Paris| 6833.333333333333|\n// | Lyon|2682.5970548862115|\n// +-----+------------------+\n//\n\nWe can also use pivot to further group data on a secondary column. \nFor example, we can compare the average price across cities by number of bedrooms.  \ncase class BedroomStats(\n   city: String, \n   AvgPriceBeds1: Option[Double], // Pivot values may be missing, so we encode them using Options\n   AvgPriceBeds2: Option[Double], \n   AvgPriceBeds3: Option[Double], \n   AvgPriceBeds4: Option[Double])\n// defined class BedroomStats\n\nval bedroomStats = aptds.\n   groupBy(aptds('city)).\n   pivot(aptds('bedrooms)).\n   on(1,2,3,4). // We only care for up to 4 bedrooms\n   agg(avg(aptds('price))).\n   as[BedroomStats]  // Typesafe casting\n// bedroomStats: frameless.TypedDataset[BedroomStats] = [city: string, AvgPriceBeds1: double ... 3 more fields]\n\nbedroomStats.show().run()\n// +-----+-------------+-------------+-------------+-------------+\n// | city|AvgPriceBeds1|AvgPriceBeds2|AvgPriceBeds3|AvgPriceBeds4|\n// +-----+-------------+-------------+-------------+-------------+\n// | Nice|         null|         null|     325000.0|         null|\n// |Paris|     250000.0|     300000.0|     450000.0|         null|\n// | Lyon|     133000.0|     200000.0|         null|         null|\n// +-----+-------------+-------------+-------------+-------------+\n//\n\nWith pivot, collecting data preserves typesafety by \nencoding potentially missing columns with Option.\nbedroomStats.collect().run().foreach(println)\n// BedroomStats(Nice,None,None,Some(325000.0),None)\n// BedroomStats(Paris,Some(250000.0),Some(300000.0),Some(450000.0),None)\n// BedroomStats(Lyon,Some(133000.0),Some(200000.0),None,None)\n\nEntire TypedDataset Aggregation\nWe often want to aggregate the entire TypedDataset and skip the groupBy() clause.\nIn Frameless you can do this using the agg() operator directly on the TypedDataset. \nIn the following example, we compute the average price, the average surface,the minimum surface, and the set of cities for the entire dataset. \ncase class Stats(\n   avgPrice: Double, \n   avgSurface: Double, \n   minSurface: Int, \n   allCities: Vector[String])\n// defined class Stats\n\naptds.agg(\n   avg(aptds('price)), \n   avg(aptds('surface)),\n   min(aptds('surface)),\n   collectSet(aptds('city))\n).as[Stats].show().run() \n// +-----------------+------------------+----------+-------------------+\n// |         avgPrice|        avgSurface|minSurface|          allCities|\n// +-----------------+------------------+----------+-------------------+\n// |276333.3333333333|62.833333333333336|        25|[Paris, Nice, Lyon]|\n// +-----------------+------------------+----------+-------------------+\n//\n\nJoins\ncase class CityPopulationInfo(name: String, population: Int)\n\nval cityInfo = Seq(\n  CityPopulationInfo(\"Paris\", 2229621),\n  CityPopulationInfo(\"Lyon\", 500715),\n  CityPopulationInfo(\"Nice\", 343629)\n)\n\nval citiInfoTypedDS = TypedDataset.create(cityInfo)\n\nHere is how to join the population information to the apartment's dataset.\nval withCityInfo = aptTypedDs.join(citiInfoTypedDS, aptTypedDs('city), citiInfoTypedDS('name))\n// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct, _2: struct]\n\nwithCityInfo.show().run()\n// +--------------------+---------------+\n// |                  _1|             _2|\n// +--------------------+---------------+\n// |[Paris,50,300000....|[Paris,2229621]|\n// |[Paris,100,450000...|[Paris,2229621]|\n// |[Paris,25,250000....|[Paris,2229621]|\n// |[Lyon,83,200000.0,2]|  [Lyon,500715]|\n// |[Lyon,45,133000.0,1]|  [Lyon,500715]|\n// |[Nice,74,325000.0,3]|  [Nice,343629]|\n// +--------------------+---------------+\n//\n\nThe joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].\nWe can then select which information we want to continue to work with:\ncase class AptPriceCity(city: String, aptPrice: Double, cityPopulation: Int)\n// defined class AptPriceCity\n\nwithCityInfo.select(\n   withCityInfo.colMany('_2, 'name), withCityInfo.colMany('_1, 'price), withCityInfo.colMany('_2, 'population)\n).as[AptPriceCity].show().run\n// +-----+--------+--------------+\n// | city|aptPrice|cityPopulation|\n// +-----+--------+--------------+\n// |Paris|300000.0|       2229621|\n// |Paris|450000.0|       2229621|\n// |Paris|250000.0|       2229621|\n// | Lyon|200000.0|        500715|\n// | Lyon|133000.0|        500715|\n// | Nice|325000.0|        343629|\n// +-----+--------+--------------+\n//\n\n"},"TypedDatasetVsSparkDataset.html":{"url":"TypedDatasetVsSparkDataset.html","title":"Comparing TypedDatasets with Spark's Datasets","keywords":"","body":"Comparing TypedDatasets with Spark's Datasets\nGoal:\n  This tutorial compares the standard Spark Datasets api with the one provided by\n  frameless' TypedDataset. It shows how TypedDatsets allows for an expressive and\n  type-safe api with no compromises on performance.\nFor this tutorial we first create a simple dataset and save it on disk as a parquet file.\nParquet is a popular columnar format and well supported by Spark.\nIt's important to note that when operating on parquet datasets, Spark knows that each column is stored\nseparately, so if we only need a subset of the columns Spark will optimize for this and avoid reading\nthe entire dataset. This is a rather simplistic view of how Spark and parquet work together but it\nwill serve us well for the context of this discussion.\nimport spark.implicits._\n// import spark.implicits._\n\n// Our example case class Foo acting here as a schema\ncase class Foo(i: Long, j: String)\n// defined class Foo\n\n// Assuming spark is loaded and SparkSession is bind to spark\nval initialDs = spark.createDataset( Foo(1, \"Q\") :: Foo(10, \"W\") :: Foo(100, \"E\") :: Nil )\n// initialDs: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\n// Assuming you are on Linux or Mac OS\ninitialDs.write.parquet(\"/tmp/foo\")\n\nval ds = spark.read.parquet(\"/tmp/foo\").as[Foo]\n// ds: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\nds.show()\n// +---+---+\n// |  i|  j|\n// +---+---+\n// |  1|  Q|\n// | 10|  W|\n// |100|  E|\n// +---+---+\n//\n\nThe value ds holds the content of the initialDs read from a parquet file.\nLet's try to only use field i from Foo and see how Spark's Catalyst (the query optimizer)\noptimizes this.\n// Using a standard Spark TypedColumn in select()\nval filteredDs = ds.filter($\"i\" === 10).select($\"i\".as[Long])\n// filteredDs: org.apache.spark.sql.Dataset[Long] = [i: bigint]\n\nfilteredDs.show()\n// +---+\n// |  i|\n// +---+\n// | 10|\n// +---+\n//\n\nThe filteredDs is of type Dataset[Long]. Since we only access field i from Foo the type is correct.\nUnfortunately, this syntax requires handholding by explicitly setting the TypedColumn in the select statement\nto return type Long (look at the as[Long] statement). We will discuss this limitation next in more detail.\nNow, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.\nfilteredDs.explain()\n// == Physical Plan ==\n// *Project [i#1131L]\n// +- *Filter (isnotnull(i#1131L) && (i#1131L = 10))\n//    +- *FileScan parquet [i#1131L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nThe last line is very important (see ReadSchema). The schema read\nfrom the parquet file only required reading column i without needing to access column j.\nThis is great! We have both an optimized query plan and type-safety!\nUnfortunately, this syntax is not bulletproof: it fails at run-time if we try to access\na non existing column x:\nscala> ds.filter($\"i\" === 10).select($\"x\".as[Long])\norg.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];;\n'Project ['x]\n+- Filter (i#1131L = cast(10 as bigint))\n   +- Relation[i#1131L,j#1132] parquet\n\n  at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:88)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:85)\n  at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n  at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n  at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:70)\n  at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:288)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:279)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:289)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1$1.apply(QueryPlan.scala:293)\n  at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n  at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n  at scala.collection.immutable.List.foreach(List.scala:392)\n  at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n  at scala.collection.immutable.List.map(List.scala:296)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:293)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$6.apply(QueryPlan.scala:298)\n  at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:187)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:298)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:268)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:85)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)\n  at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)\n  at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)\n  at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)\n  at org.apache.spark.sql.Dataset.(Dataset.scala:164)\n  at org.apache.spark.sql.Dataset.(Dataset.scala:170)\n  at org.apache.spark.sql.Dataset.select(Dataset.scala:1213)\n  ... 454 elided\n\nThere are two things to improve here. First, we would want to avoid the at[Long] casting that we are required\nto type for type-safety. This is clearly an area where we can introduce a bug by casting to an incompatible\ntype. Second, we want a solution where reference to a\nnon existing column name fails at compilation time.\nThe standard Spark Dataset can achieve this using the following syntax.\nds.filter(_.i == 10).map(_.i).show()\n// +-----+\n// |value|\n// +-----+\n// |   10|\n// +-----+\n//\n\nThis looks great! It reminds us the familiar syntax from Scala.\nThe two closures in filter and map are functions that operate on Foo and the\ncompiler will helps us capture all the mistakes we mentioned above.\nscala> ds.filter(_.i == 10).map(_.x).show()\n:20: error: value x is not a member of Foo\n       ds.filter(_.i == 10).map(_.x).show()\n                                  ^\n\nUnfortunately, this syntax does not allow Spark to optimize the code.\nds.filter(_.i == 10).map(_.i).explain()\n// == Physical Plan ==\n// *SerializeFromObject [input[0, bigint, false] AS value#1165L]\n// +- *MapElements , obj#1164: bigint\n//    +- *Filter .apply\n//       +- *DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#1163: $line14.$read$$iw$$iw$$iw$$iw$Foo\n//          +- *FileScan parquet [i#1131L,j#1132] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [], ReadSchema: struct\n\nAs we see from the explained Physical Plan, Spark was not able to optimize our query as before.\nReading the parquet file will required loading all the fields of Foo. This might be ok for\nsmall datasets or for datasets with few columns, but will be extremely slow for most practical\napplications.\nIntuitively, Spark currently doesn't have a way to look inside the code we pass in these two\nclosures. It only knows that they both take one argument of type Foo, but it has no way of knowing if\nwe use just one or all of Foo's fields.\nThe TypedDataset in frameless solves this problem. It allows for a simple and type-safe syntax\nwith a fully optimized query plan.\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport frameless.syntax._\n// import frameless.syntax._\n\nval fds = TypedDataset.create(ds)\n// fds: frameless.TypedDataset[Foo] = [i: bigint, j: string]\n\nfds.filter( fds('i) === 10 ).select( fds('i) ).show().run()\n// +---+\n// | _1|\n// +---+\n// | 10|\n// +---+\n//\n\nAnd the optimized Physical Plan:\nfds.filter( fds('i) === 10 ).select( fds('i) ).explain()\n// == Physical Plan ==\n// *Project [i#1131L AS _1#1236L]\n// +- *Filter (isnotnull(i#1131L) && (i#1131L = 10))\n//    +- *FileScan parquet [i#1131L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nAnd the compiler is our friend.\nscala> fds.filter( fds('i) === 10 ).select( fds('x) )\n:24: error: No column Symbol with shapeless.tag.Tagged[String(\"x\")] of type A in Foo\n       fds.filter( fds('i) === 10 ).select( fds('x) )\n                                               ^\n\nDifferences in Encoders\nEncoders in Spark's Datasets are partially type-safe. If you try to create a Dataset using  a type that is not \n a Scala Product then you get a compilation error:\nclass Bar(i: Int)\n// defined class Bar\n\nBar is neither a case class nor a Product, so the following correctly gives a compilation error in Spark:\nscala> spark.createDataset(Seq(new Bar(1)))\n:24: error: Unable to find encoder for type stored in a Dataset.  Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._  Support for serializing other types will be added in future releases.\n       spark.createDataset(Seq(new Bar(1)))\n                          ^\n\nHowever, the compile type guards implemented in Spark are not sufficient to detect non encodable members. \nFor example, using the following case class leads to a runtime failure:\ncase class MyDate(jday: java.util.Date)\n// defined class MyDate\n\nval myDateDs = spark.createDataset(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// java.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n// - field (class: \"java.util.Date\", name: \"jday\")\n// - root class: \"MyDate\"\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:625)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$10.apply(ScalaReflection.scala:619)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$10.apply(ScalaReflection.scala:607)\n//   at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n//   at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n//   at scala.collection.immutable.List.foreach(List.scala:392)\n//   at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n//   at scala.collection.immutable.List.flatMap(List.scala:355)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:607)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:438)\n//   at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:71)\n//   at org.apache.spark.sql.Encoders$.product(Encoders.scala:275)\n//   at org.apache.spark.sql.LowPrioritySQLImplicits$class.newProductEncoder(SQLImplicits.scala:233)\n//   at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:33)\n//   ... 778 elided\n\nIn comparison, a TypedDataset will notify about the encoding problem at compile time: \nTypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// :25: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[MyDate]\n//        TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n//                           ^\n\n"},"TypedEncoder.html":{"url":"TypedEncoder.html","title":"Typed Encoders in Frameless","keywords":"","body":"Typed Encoders in Frameless\nSpark uses Reflection to derive it's Encoders, which is why they can fail at run time. For example, because Spark does not supports java.util.Date, the following leads to an error:\nimport org.apache.spark.sql.Dataset\nimport spark.implicits._\n\ncase class DateRange(s: java.util.Date, e: java.util.Date)\n\nscala> val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))\njava.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n- field (class: \"java.util.Date\", name: \"s\")\n- root class: \"DateRange\"\n  at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:625)\n  at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$10.apply(ScalaReflection.scala:619)\n  at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$10.apply(ScalaReflection.scala:607)\n  at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n  at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n  at scala.collection.immutable.List.foreach(List.scala:392)\n  at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n  at scala.collection.immutable.List.flatMap(List.scala:355)\n  at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:607)\n  at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:438)\n  at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:71)\n  at org.apache.spark.sql.Encoders$.product(Encoders.scala:275)\n  at org.apache.spark.sql.LowPrioritySQLImplicits$class.newProductEncoder(SQLImplicits.scala:233)\n  at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:33)\n  ... 242 elided\n\nAs shown by the stack trace, this runtime error goes thought ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection based approach is it's inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.\nFrameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the code java.util.Date example won't compile with frameless:\nimport frameless.TypedDataset\nimport frameless.syntax._\n\nval ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// :29: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]\n//        val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n//                                                             ^\n\nType class derivation takes care of recursively constructing (and proving the existence of) TypeEncoders for case classes. The following works as expected:\ncase class Bar(d: Double, s: String)\n// defined class Bar\n\ncase class Foo(i: Int, b: Bar)\n// defined class Foo\n\nval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, \"s\"))))\n// ds: frameless.TypedDataset[Foo] = [i: int, b: struct]\n\nds.collect()\n// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@208e2282\n\nBut any non-encodable in the case class hierarchy will be detected at compile time:\ncase class BarDate(d: Double, s: String, t: java.util.Date)\ncase class FooDate(i: Int, b: BarDate)\n\nval ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// :31: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]\n//        val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n//                                                           ^\n\nIt should be noted that once derived, reflection based Encoders and implicitly derived TypeEncoders have identical performances. The derivation mechanism is different, but the objects generated to encode and decode JVM object in the Spark internal representation behave the same at run-time.\n"},"Injection.html":{"url":"Injection.html","title":"Injection: Creating Custom Encoders","keywords":"","body":"Injection: Creating Custom Encoders\nInjection lets us define encoders for types that do not have one by injecting A into an encodable type B.\nThis is the definition of the injection typeclass:\ntrait Injection[A, B] extends Serializable {\n  def apply(a: A): B\n  def invert(b: B): A\n}\n\nExample\nLet's define a simple case class:\ncase class Person(age: Int, birthday: java.util.Date)\n// defined class Person\n\nval people = Seq(Person(42, new java.util.Date))\n// people: Seq[Person] = List(Person(42,Wed Oct 18 09:21:38 PDT 2017))\n\nAnd an instance of a TypedDataset:\nval personDS = TypedDataset.create(people)\n// :24: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n//        val personDS = TypedDataset.create(people)\n//                                          ^\n\nLooks like we can't, a TypedEncoder instance of Person is not available, or more precisely for java.util.Date.\nBut we can define a injection from java.util.Date to an encodable type, like Long:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = new Injection[java.util.Date, Long] {\n  def apply(d: java.util.Date): Long = d.getTime()\n  def invert(l: Long): java.util.Date = new java.util.Date(l)\n}\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@2b4ee43e\n\nWe can be less verbose using the Injection.apply function:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@5a548922\n\nNow we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, birthday: bigint]\n\nAnother example\nLet's define a sealed family:\nsealed trait Gender\n// defined trait Gender\n\ncase object Male extends Gender\n// defined object Male\n\ncase object Female extends Gender\n// defined object Female\n\ncase object Other extends Gender\n// defined object Other\n\nAnd a simple case class:\ncase class Person(age: Int, gender: Gender)\n// defined class Person\n\nval people = Seq(Person(42, Male))\n// people: Seq[Person] = List(Person(42,Male))\n\nAgain if we try to create a TypedDataset, we get a compilation error.\nval personDS = TypedDataset.create(people)\n// :32: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n//        val personDS = TypedDataset.create(people)\n//                                          ^\n\nLet's define an injection instance for Gender:\nimplicit val genderToInt: Injection[Gender, Int] = Injection(\n  {\n    case Male   => 1\n    case Female => 2\n    case Other  => 3\n  },\n  {\n    case 1 => Male\n    case 2 => Female\n    case 3 => Other\n  })\n// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@62c73008\n\nAnd now we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, gender: int]\n\n"},"Job.html":{"url":"Job.html","title":"Job[A]","keywords":"","body":"Job[A]\nAll operations on TypedDataset are lazy. An operation either returns a new\ntransformed TypedDataset or an F[A], where F[_] is a type constructor\nwith an instance of the SparkDelay typeclass and A is the result of running a\nnon-lazy computation in Spark. \nA default such type constructor called Job is provided by Frameless. \nJob serves several functions:\n\nMakes all operations on a TypedDataset lazy, which makes them more predictable compared to having\nfew operations being lazy and other being strict\nAllows the programmer to make expensive blocking operations explicit\nAllows for Spark jobs to be lazily sequenced using monadic composition via for-comprehension\nProvides an obvious place where you can annotate/name your Spark jobs to make it easier\nto track different parts of your application in the Spark UI\n\nThe toy example showcases the use of for-comprehension to explicitly sequences Spark Jobs.\nFirst we calculate the size of the TypedDataset and then we collect to the driver\nexactly 20% of its elements:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval ds = TypedDataset.create(1 to 20)\n// ds: frameless.TypedDataset[Int] = [_1: int]\n\nval countAndTakeJob =\n  for {\n    count \nThe countAndTakeJob can either be executed using run() (as we show above) or it can\nbe passed along to other parts of the program to be further composed into more complex sequences\nof Spark jobs.\nimport frameless.Job\n// import frameless.Job\n\ndef computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min)\n// computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]\n\nval finalJob = computeMinOfSample(countAndTakeJob)\n// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@6ef768bf\n\nNow we can execute this new job by specifying a group-id and a description.\nThis allows the programmer to see this information on the Spark UI and help track, say,\nperformance issues.\nfinalJob.\n  withGroupId(\"samplingJob\").\n  withDescription(\"Samples 20% of elements and computes the min\").\n  run()\n// res2: Int = 1\n\nMore on SparkDelay\nAs mentioned above, SparkDelay[F[_]] is a typeclass required for suspending\neffects by Spark computations. This typeclass represents the ability to suspend\nan => A thunk into an F[A] value, while implicitly capturing a SparkSession.\nAs it is a typeclass, it is open for implementation by the user in order to use\nother data types for suspension of effects. The cats module, for example, uses\nthis typeclass to support suspending Spark computations in any effect type that\nhas a cats.effect.Sync instance.\n"},"Cats.html":{"url":"Cats.html","title":"Using Cats with RDDs","keywords":"","body":"Using Cats with Frameless\nThere are two main parts to the cats integration offered by frameless:\n\neffect suspension in TypedDataset using cats-effect and cats-mtl\nRDD enhancements using algebraic typeclasses in cats-kernel\n\nAll the examples below assume you have previously imported cats.implicits and frameless.cats.implicits.\nNote that you should not import frameless.syntax._ together with frameless.cats.implicits._.\nimport cats.implicits._\n// import cats.implicits._\n\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nEffect Suspension in typed datasets\nAs noted in the section about Job, all operations on TypedDataset are lazy. The results of \noperations that would normally block on plain Spark APIs are wrapped in a type constructor F[_], \nfor which there exists an instance of SparkDelay[F]. This typeclass represents the operation of \ndelaying a computation and capturing an implicit SparkSession. \nIn the cats module, we utilize the typeclasses from cats-effect for abstracting over these \neffect types - namely, we provide an implicit SparkDelay instance for all F[_] for which exists\nan instance of cats.effect.Sync[F].\nThis allows one to run operations on TypedDataset in an existing monad stack. For example, given\nthis pre-existing monad stack:\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport cats.data.ReaderT\n// import cats.data.ReaderT\n\nimport cats.effect.IO\n// import cats.effect.IO\n\nimport cats.effect.implicits._\n// import cats.effect.implicits._\n\ntype Action[T] = ReaderT[IO, SparkSession, T]\n// defined type alias Action\n\nWe will be able to request that values from TypedDataset will be suspended in this stack:\nval typedDs = TypedDataset.create(Seq((1, \"string\"), (2, \"another\")))\n// typedDs: frameless.TypedDataset[(Int, String)] = [_1: int, _2: string]\n\nval result: Action[(Seq[(Int, String)], Long)] = for {\n  sample )\n\nAs with Job, note that nothing has been run yet. The effect has been properly suspended. To\nrun our program, we must first supply the SparkSession to the ReaderT layer and then\nrun the IO effect:\nresult.run(spark).unsafeRunSync()\n// res5: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)\n\nConvenience methods for modifying Spark thread-local variables\nThe frameless.cats.implicits._ import also provides some syntax enrichments for any monad\nstack that has the same capabilities as Action above. Namely, the ability to provide an\ninstance of SparkSession and the ability to suspend effects.\nFor these to work, we will need to import the implicit machinery from the cats-mtl library:\nimport cats.mtl.implicits._\n// import cats.mtl.implicits._\n\nAnd now, we can set the description for the computation being run:\nval resultWithDescription: Action[(Seq[(Int, String)], Long)] = for {\n  r )\n\nresultWithDescription.run(spark).unsafeRunSync()\n// Description: fancy cats\n// res6: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)\n\nUsing algebraic typeclasses from Cats with RDDs\nData aggregation is one of the most important operations when working with Spark (and data in general).\nFor example, we often have to compute the min, max, avg, etc. from a set of columns grouped by\ndifferent predicates. This section shows how cats simplifies these tasks in Spark by\nleveraging a large collection of Type Classes for ordering and aggregating data.\nCats offers ways to sort and aggregate tuples of arbitrary arity.\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nval data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[14] at makeRDD at :45\n\nprintln(data.csum)\n// (10,9,9)\n\nprintln(data.cmax)\n// (8,2,3)\n\nprintln(data.cmin)\n// (1,2,3)\n\nThe following example aggregates all the elements with a common key.\ntype User = String\n// defined type alias User\n\ntype TransactionCount = Int\n// defined type alias TransactionCount\n\nval allData: RDD[(User,TransactionCount)] =\n   sc.makeRDD((\"Bob\", 12) :: (\"Joe\", 1) :: (\"Anna\", 100) :: (\"Bob\", 20) :: (\"Joe\", 2) :: Nil)\n// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[15] at makeRDD at :48\n\nval totalPerUser =  allData.csumByKey\n// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[16] at reduceByKey at implicits.scala:18\n\ntotalPerUser.collectAsMap\n// res10: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)\n\nThe same example would work for more complex keys.\nval allDataComplexKeu =\n   sc.makeRDD( (\"Bob\", Map(\"task1\" -> 10)) ::\n    (\"Joe\", Map(\"task1\" -> 1, \"task2\" -> 3)) :: (\"Bob\", Map(\"task1\" -> 10, \"task2\" -> 1)) :: (\"Joe\", Map(\"task3\" -> 4)) :: Nil )\n// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ParallelCollectionRDD[17] at makeRDD at :46\n\nval overalTasksPerUser = allDataComplexKeu.csumByKey\n// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.Map[String,Int])] = ShuffledRDD[18] at reduceByKey at implicits.scala:18\n\noveralTasksPerUser.collectAsMap\n// res11: scala.collection.Map[String,scala.collection.immutable.Map[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))\n\nJoins\n// Type aliases for meaningful types\ntype TimeSeries = Map[Int,Int]\n// defined type alias TimeSeries\n\ntype UserName = String\n// defined type alias UserName\n\nExample: Using the implicit full-our-join operator\nimport frameless.cats.outer._\n// import frameless.cats.outer._\n\nval day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 2, 1 -> 4)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Sam\", Map(0 -> 1)) :: Nil )\n// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[19] at makeRDD at :50\n\nval day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 10, 1 -> 11)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Joe\", Map(0 -> 1, 1 -> 2)) :: Nil )\n// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[20] at makeRDD at :50\n\nval daysCombined = day1 |+| day2\n// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[24] at mapValues at implicits.scala:43\n\ndaysCombined.collect()\n// res13: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))\n\nNote how the user's timeseries from different days have been aggregated together.\nThe |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join\non the key and combine values using the default Semigroup for the value type.\nIn cats:\nMap(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)\n// res14: Map[Int,Int] = Map(1 -> 6, 2 -> 2)\n\n"},"TypedML.html":{"url":"TypedML.html","title":"Using Spark ML with TypedDataset","keywords":"","body":"TypedDataset support for Spark ML\nThe goal of the frameless-ml module is to be able to use Spark ML with TypedDataset and\nto eventually provide a more strongly typed ML API for Spark. Currently, this module is at its very beginning and only \nprovides TypedEncoder instances for Spark ML's linear algebra data types.\nUsing Vector and Matrix with TypedDataset\nframeless-ml provides TypedEncoder instances for org.apache.spark.ml.linalg.Vector \nand org.apache.spark.ml.linalg.Matrix:\nimport frameless.ml._\n// import frameless.ml._\n\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport org.apache.spark.ml.linalg._\n// import org.apache.spark.ml.linalg._\n\nval vector = Vectors.dense(1, 2, 3)\n// vector: org.apache.spark.ml.linalg.Vector = [1.0,2.0,3.0]\n\nval vectorDs = TypedDataset.create(Seq(\"label\" -> vector))\n// vectorDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Vector)] = [_1: string, _2: vector]\n\nval matrix = Matrices.dense(2, 1, Array(1, 2))\n// matrix: org.apache.spark.ml.linalg.Matrix =\n// 1.0\n// 2.0\n\nval matrixDs = TypedDataset.create(Seq(\"label\" -> matrix))\n// matrixDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Matrix)] = [_1: string, _2: matrix]\n\nUnder the hood, Vector and Matrix are encoded using org.apache.spark.ml.linalg.VectorUDT \nand org.apache.spark.ml.linalg.MatrixUDT. This is possible thanks to the implicit derivation \nfrom org.apache.spark.sql.types.UserDefinedType[A] to TypedEncoder[A] defined in TypedEncoder companion object.\n"},"TypedDataFrame.html":{"url":"TypedDataFrame.html","title":"Proof of Concept: TypedDataFrame","keywords":"","body":"Proof of Concept: TypedDataFrame\nTypedDataFrame is the API developed in the early stages of frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future developments of frameless. However, the design is interesting enough for being documented.\nTo safely manipulate DataFrames we use a technique called shadow type, which consists in storing additional information about a value in a \"dummy\" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.\nDiving in\nIn TypedDataFrame, we use a single Schema  to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:\nimport org.apache.spark.sql.DataFrame\nimport shapeless.HList\n\nclass TDataFrame[Schema  Boolean): TDataFrame[Schema] = ???\n\n  def select[C \nAs you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.\nType-level column referencing\nFor Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching column referencing at compile type. When everything goes well, frameless select is very similar to vanilla select, except that it keeps track of the selected column types:\nimport frameless.TypedDataFrame\n\ncase class Foo(s: String, d: Double, i: Int)\n\ndef selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n  tf.select('i, 's)\n\nHowever, in case of typo, it gets coughs right away:\ndef selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n  tf.select('j, 's)\n\nType-level joins\nJoins can available with two different syntaxes, the first lets you reference different columns on each TypedDataFrame, and ensures that their all exists and have compatible types:\ncase class Bar(i: Int, j: String, b: Boolean)\n\ndef join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n    : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =\n  tf1.innerJoin(tf2).on('s).and('j)\n\nThe second syntax bring some convenience when the joining columns have identical names in both tables:\ndef join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n    : TypedDataFrame[(String, Double, Int, String, Boolean)] =\n  tf1.innerJoin(tf2).using('i)\n\nFurther example are available in the TypedDataFrame join tests.\nComplete example\nWe now consider a complete example to see how the type system can frameless can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city map and neighborhood:\ntype Neighborhood = String\ntype Address = String\n\ncase class PhoneBookEntry(\n  address: Address,\n  residents: String,\n  phoneNumber: Double\n)\n\ncase class CityMapEntry(\n  address: Address,\n  neighborhood: Neighborhood\n)\n\nOur goal will be to compute the neighborhood with unique names, approximating \"unique\" with names containing less common\nletters in the alphabet: 'x', 'q', and 'z'. We are going to need a natural language processing library at some point, so\nlet's use the following for the example:\nobject NLPLib {\n  def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))\n}\n\nSuppose we manage to obtain a TypedDataFrame[PhoneBookEntry] and a TypedDataFrame[CityMapEntry] public data, here is what our Spark job could look like with frameless:\nimport org.apache.spark.sql.SQLContext\n\n// These case classes are used to hold intermediate results\ncase class Family(residents: String, neighborhood: Neighborhood)\ncase class Person(name: String, neighborhood: Neighborhood)\ncase class NeighborhoodCount(neighborhood: Neighborhood, count: Long)\n\ndef bestNeighborhood\n  (phoneBookTF: TypedDataFrame[PhoneBookEntry], cityMapTF: TypedDataFrame[CityMapEntry])\n  (implicit c: SQLContext): String = {\n                                          (((((((((\n  phoneBookTF\n    .innerJoin(cityMapTF).using('address) :TypedDataFrame[(Address, String, Double, String)])\n    .select('_2, '_4)                     :TypedDataFrame[(String, String)])\n    .as[Family]()                         :TypedDataFrame[Family])\n    .flatMap { f =>\n      f.residents.split(' ').map(r => Person(r, f.neighborhood))\n    }                                     :TypedDataFrame[Person])\n    .filter { p =>\n      NLPLib.uniqueName(p.name)\n    }                                     :TypedDataFrame[Person])\n    .groupBy('neighborhood).count()       :TypedDataFrame[(String, Long)])\n    .as[NeighborhoodCount]()              :TypedDataFrame[NeighborhoodCount])\n    .sortDesc('count)                     :TypedDataFrame[NeighborhoodCount])\n    .select('neighborhood)                :TypedDataFrame[Tuple1[String]])\n    .head._1\n}\n\nIf you compare this version from Spark vanilla where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.\nLimitations\nThe main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.\nIn the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.\n"}}}
\ No newline at end of file
+{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["\"0.5.0\"","\"frameless","\"org.typelevel\"","%","%%","(e.g.","(e.g.,","(includ","(peopl","(thumb",")","++=","+1,","0.13.13:","0.4.0","0.4.1","0.5.0","1.0.0","1.0.1","2.0","2.0,","2.11.x.","2.2.0","2.2.1","2.3.2.","=",">=","access","add","adelbertc","aforement","against","allow","apach","api","api,","api.","appli","applic","are:","arithmet","associ","avail","base","benefit","bootstrap","break","bring","build.sbt","built","call","cast","cat","cats\"","cats,","cats.","chang","channel","choos","click","code","column","column,","columns)","compar","comparison","compat","compil","compile)","concept:","conduct","consist","consol","contribut","contributor","creat","current","custom","customizable,","dataset","dataset\"","dataset,","dataset/datafram","depend","detail","develop","document","easi","encod","encoder,","enhanc","environ","error","error)","essenti","exist","express","featur","feel","few","file","file.","follow","follows:","frameless","framelessvers","framelessversion,","free","friendli","function","g8","get","giter8","github,","gitter","gitter)","ground,","help?","here","http://opensource.org/licenses/apach","imario","imarios/frameless.g8","injection:","insid","instal","intention","introduc","introduct","issues/questions.","jar.","jeremyrsmith","job[a]","kanterov","learning.","librari","librarydepend","licens","list(","load","made","maintain","merg","messag","mf","minim","ml","ml\"","modul","modules:","more","need","needed:","new","next","non","note","numer","offici","olivierblanvillain","on","oper","overhead","overview","possibl","prefer","probabl","project","project:","projectio","proof","provid","pull","quick","rdd","rdds,","referenc","requests)","requests.","requir","runtim","safe","same","sbt","scala","shapeless","shell","sign","signatur","similar)","simpli","simply:","spark","spark'","spark).","spark.","standard","start","still","strongli","support","tabl","test","therefore,","type","typeddatafram","typeddataset","typeddataset.","typeddataset:","typelevel","types.","typesaf","under","up","up,","us","val","veri","version","versions.","want","way","well","well.","why?","with,","work"],"FeatureOverview.html":["\"abc\")","\"false\")","\"lyon\",","\"paris\")","\"paris\",","$\"*\".","'`citi`'","'city),","'name),","'population)","'price),","'project","(apttypedds)","(apttypedds2)","(column:","(enjoy","(frameless.typedcolumn[(string,","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(from","(if","(in","(lyon,166500.0))","(name:","(paris,333333.3333333333),","(string,","(such","(u:","(up","(which","(with",")",").as[apartmentdetails]",").as[aptpricecity].show().run",").as[stats].show().run()",").show().run()",").show(1).run()",").show(2).run()","*","+","...","...).",".ac",".dataset",".desc.",".select($\"*\",","/","//","0.0|","0.0|325000.0|","0.2,","1","1),","1.1|","10,","100,","10000.0,","102|","133000.0,","133000.0|","1|","1|250000.0|","2","2)","2),","2).as[updatedsurface]","2).show().run()","2.0","200000.0,","200000.0|","2229621),","2229621|","2409.6385542168673,","25,","250000.0,","250000.0|","250|","25|[paris,","27|","2955.5555555555557,","2|","2|300000.0|","2|[a,","3","3)","3),","300000.0,","300000.0|","325000.0,","325000.0|","343629)","343629|","3|","3|450000.0|","3|[a,","4","430","4391.891891891892)","4391.891891891892|","45,","4500.0,","450000.0,","450000.0|","450|","45|133000.0|","47|","50,","500715),","500715|","500|","52|","6833.333333333333|","74,","740|","76|","83,","830|","83|200000.0|","85|",":",":26:",":27:",":28:",":29:",":35:",":36:","=","==","===","=>","['citi]","[1...10]).","[_1:","[city#53,","[city,","[city:","[lyon,500715]|","[nice,343629]|","[out,","[ratio:","^","_1|","_2:","_2|","_3|","_4|","a)(implicit","ab","abov","access","accident","action","actual","ad","add","addit","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","agg()","agg(avg(aptds('price))).","aggreg","aggregated,","agree.","align","align.","allcities:","allcities|","allow","allowed,","allowed:","alternatives:","and/or","anoth","anyth","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartment.","apartmentdetail","apartmentdetails(city:","apartmentdetails?","apartmentshortinfo","apartmentshortinfo(city:","apartmentshortinfo?","api","api,","api.","apis),","apis.","appear","appli","aptd","aptds('city),","aptds('price)","aptds('price)))","aptds('price),","aptds('surface),","aptds('surface).cast[double]","aptds('surface).cast[double])","aptds.","aptds.agg(","aptds.select(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)","apttypedds('city)).as[updatedsurface]","apttypedds('city).asc,","apttypedds('city).cast[double]","apttypedds('price).desc","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.joininner(citiinfotypedds)","apttypedds.makeudf(pricemodifier)","apttypedds.orderby(","apttypedds.orderby(apttypedds('city).asc).show(2).run()","apttypedds.project[apartmentshortinfo]","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds.union(apttypedds2).show().run","apttypedds2","apttypedds2('price)","apttypedds2('price)).","apttypedds2.drop[citybeds]","apttypedds2.droptupled('price):","apttypedds2.union(apttypedds).show().run","apttypedds2.withcolumnreplaced('price,","apttypedds2.withcolumntupled(","apttypedds2.withcolumntupled(lit(array(\"a\",\"b\",\"c\"))).show(2).run()","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","argument","arguments)","around","array]","arraycontains(t('_1),","arraycontains(t('_2),","arraycontains:","as:","as[bedroomstats]","as[t]","ascol()","ascol(),","avail","available.","averag","avg","avg(aptds('price))","avg(aptds('price)),","avg(aptds('surface))","avg(aptds('surface)),","avgprice:","avgpricebeds1:","avgpricebeds2:","avgpricebeds3:","avgpricebeds4:","avgprice|","avgsurface:","avgsurface|minsurface|","avoid","b,","base","bedroom","bedrooms#56]","bedrooms.","bedrooms:","bedrooms];;","bedroomstat","bedroomstats(","bedroomstats('avgpricebeds2).getorelse(0.0),","bedroomstats('avgpricebeds3).getorelse(0.0))","bedroomstats(lyon,some(133000.0),some(200000.0),none,none)","bedroomstats(nice,none,none,some(325000.0),none)","bedroomstats(paris,some(250000.0),some(300000.0),some(450000.0),none)","bedroomstats.collect().run().foreach(println)","bedroomstats.select(","bedroomstats.show().run()","bedroomstats:","better","between","boolean","boolean)].","c","c('_2)).show(2).run()","c,","c.","c.select(c.colmany('_1,","c.show(1).run()","c:","c]|","calcul","call","caller","can't","care","case","case.","cast","cast,","catalystcast.","catalystcast[string,","chang","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name)","city:","cityb","citybeds(city:","citybeds(lyon,2))","citybeds(paris,1))","citybeds(paris,1),","citybeds(paris,3))","citybeds(paris,3),","citybeds.","citybeds.head(3).run()","citybeds.headoption.run()","citybeds.limit(4).collect().run()","citybeds.select(citybeds.ascol,","citybeds.take(2).run()","citybeds:","citybedsoth","citybedsother(city:","cityinfo","cityinfo(city:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.select(cityratio('city),","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|avgpricebeds1|avgpricebeds2|avgpricebeds3|avgpricebeds4|","city|bedrooms|","city|surface|","class","class:","clause.","code","collect","collect())","collection,","collectset(aptds('city))","colmany()","column","column.","column:","columns,","columns:","combin","compar","compat","compil","compile,","compile.","compile:","compiles:","complet","comput","computations.","concat,","condition","conf","context","continu","convert","correspond","count,","creat","d]|true|","data","datafram","dataframes,","dataset","dataset.","dataset:","defin","detail","direct","directli","divid","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","drop","drop().","drop/replace/add","droptupled()","e.g.,","e:","each","easili","element","elements.","elid","empti","encod","entir","equival","error","error.","error:","evid","evidence$1:","exampl","example,","example.","exist","expect","explan","explicitli","expos","express","expression'","extra","featur","few","field","field]","fields.","fields]","finally,","find","first","five","follow","form","formal","found","frameless","frameless'","frameless,","frameless.abstracttypedcolumn[?t,?c[?a]]","frameless.abstracttypedcolumn[t,c[a]]","frameless.abstracttypedcolumn[t,c[a]],","frameless.catalystcast[string,double]","frameless.catalystcollection[c])column.thistype[t,boolean]","frameless.catalystdivisible[double,out],","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.functions._","frameless.functions.aggregate._","frameless.functions.lit","frameless.functions.nonaggregate._","frameless.functions.nonaggregate.when","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[(string,","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[tt,double])(implicit","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(citybeds,","frameless.typeddataset[(double,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[apartmentshortinfo]","frameless.typeddataset[bedroomstats]","frameless.typeddataset[citybeds]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","frameless.typedencoder[out],","frameless.with[apartment,tt]{typ","function","functions.","further","gener","get","getorelse().","give","given","group","groupbi","groupby()","groupby(aptds('city)).","here","here.","however,","id","if(nam","implicit","import","includ","inflat","inflation.show(2).run()","inflation:","inform","initi","input","instanc","instances:","instanti","instead.","int","int)","int).","int)]","int,","int.","int]","interest","introduc","job","join","lazi","lazy.","let","let'","lift","list[string])","list[string]),string]","list[string]),string],","list[string])]","lit(0.001))","lit(1.1)).","lit(list(\"a\",\"b\",\"c\")))","lit(list(\"abc\",\"c\",\"d\")))","litaggr(\"hello","liter","localrel","long","look","loos","lyon]|","lyon|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","macro","main","make","mani","match","materialize.","math","matter","member","method","method,","method.","min(aptds('surface)),","min(aptds('surface)).cast[double],","minimum","minsurface:","mismatch;","miss","missing,","misspel","mistak","more","n","n:","name","name:","names/typ","names/types,","need","nest","new","next","next,","nice,","nice|","nice|325000.0|","non","none).","not,","note","now","null|","number","often,","on","on(1,2,3,4).","oper","operation.","operations:","option","option.","option[citybeds]","option[double])","option[double],","order","order.","org.apache.spark.sql,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:88)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$6.apply(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1$1.apply(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$transformexpressionsup$1.apply(queryplan.scala:268)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:289)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:268)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:70)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:289)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:127)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:187)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:288)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:67)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2884)","org.apache.spark.sql.dataset.select(dataset.scala:1150)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:52)","org.apache.spark.sql.sparksess","org.apache.spark.{sparkconf,","origin","other:","otherwise(lit(0.0))).show(8).run()","other|","out","overload","overview","paramet","particular","per","perform","perhap","pivot","pivot(aptds('bedrooms)).","pivot,","popul","population:","potenti","prefer","preserv","price","price#55,","price,","price/surfac","price:","price:double)","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","price|bedrooms|","project","project,","prove","rais","ratio","ratio:","ratio|","readi","referenc","repl\").set(\"spark.ui.enabled\",","replac","requir","required:","res17:","res19:","res27:","res28:","res29:","res30:","res35:","res6:","resolv","result","result.","retriev","return","right?","row","run()","runtim","safe","safe,","safe.","safety,","safety.","same","samplestat","samplestats.show().run()","samplestats:","scala","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","schema","schema.","secondari","see","seem","select","select()","selectmany()","selectmany,","seq(","seq[(string,","seq[citybeds]","seq[double]","set","shapeless.tag.tagged[string(\"citi\")]","shorter","show","show()","show(1).run()","similarly,","simpl","singl","skip","some(citybeds(paris,2))","sort","sorting.","sourc","spark","spark'","spark.createdataset(apartments)","spark.implicits._","spark.sparkcontext.setloglevel(\"warn\")","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","stack","standard","start","stat","stats(","string","string(\"abc\")","string)","string),updatedsurface]","string,","string.","string]","struct,","struct]","subset","suggests,","sum,","support","suppos","surfac","surface#54,","surface,","surface:","symbol","syntax:","t","t.withcolumntupled(","t:","take","tell","ten","those","three","time","time,","top","trace):","transform","transformations.","tri","tt,","tupl","tutori","type","type:","type;","typedaggreg","typedcolumn","typeddataset","typeddataset.","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[(string,int)]","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[apartmentshortinfo]","typeddataset[citybeds]","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","types,","typesaf","typesafeti","typo","u","udf","udf(aptds('city),","udf:","underli","union","unit:","unlik","unsaf","up","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","val","valid","valu","value.","value:","vector[string])","w:","w](other:","want","way","way,","well.","when(apttypedds2('city)","when/otherwis","whenev","wherea","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withcolumn()","withcolumn(),","withcolumn[citybedsother](lit(list(\"a\",\"b\",\"c\"))).","withcolumntupled()","without","work","worked,","world\")","world|","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","wrappedarray(citybeds(paris,2),","w})frameless.typedcolumn[w,out]","{","|","|1000|102|","|200000.0|","|276333.3333333333|62.833333333333336|","|300000.0|450000.0|","|4500.0|450000.0|","|6000.0|300000.0|","|6908333.333333333|12.566666666666668|hello","|[lyon,45,133000.0,1]|","|[lyon,83,200000.0,2]|","|[nice,74,325000.0,3]|","|[paris,100,450000...|[paris,2229621]|","|[paris,25,250000....|[paris,2229621]|","|[paris,2]|[a,","|[paris,50,300000....|[paris,2229621]|","|city|surface|","|lyon|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|paris|[a,","|paris|[abc,","}"],"TypedDatasetVsSparkDataset.html":["\"e\")","\"java.util.date\",","\"jday\")","\"mydate\"","\"q\")","\"w\")","$\"i\"*2)","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","&&","'(sum(`i`)","'`i`'","'`x`'","'project","(case","(class:","(i","(i#1771l","(int,","(isnotnull(i#1771l)","(look","(or","(see","(the",")","*","*deserializetoobject","*filescan","*filter","*mapel","*project","*serializefromobject","+",",","...",".appli","//","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10).select(fds('i)).explain()","10).select(fds('i)).show().run()","10).select(fds('x))","10|","1|","2)#1890l]","454","770","854",":",":20:",":24:",":25:",":26:","::","=","==","===","=>","['x]","[],","[a]frameless.typedcolumn[foo,a]","[i#1771l","[i#1771l,j#1772]","[i#1771l]","[i,","[i:","[input[0,","[isnotnull(i),","[out]frameless.typedaggregate[foo,out]","[sum(i#1771l)","^","_1#1876l]","_1|","`sum(i)`)'","above.","access","achiev","act","ad","aggreg","allow","api","appli","applications.","area","argument","as[long]","assum","averaging,","avoid","bar","bar(1)))","bar(i:","batched:","before.","between","bigint","bigint))","bigint,","bigint]","bind","both","bug","bulletproof:","captur","care","case","cast","cast(10","cast(2","catalyst","class","class:","classes)","clearli","closur","closures.","code","code.","column","columnar","columns,","columns:","compar","comparison,","compil","compromis","confus","content","context","correct.","correctli","creat","current","dataset","dataset.","dataset[long].","datasets,","defin","detail.","detect","differ","discuss","discussion.","disk","distinguish","don't","ds","ds.filter($\"i\"","ds.filter(_.i","ds.select(sum($\"i\"),","ds.show()","ds:","each","elid","empty,","encod","encoder:","entir","equalto(i,10)],","error","error.","error:","etc)","exampl","example,","exist","expect","explain","explicitli","express","extrem","e|","fail","failure:","false]","familiar","fd","fds('i)).show().run()","fds.agg(fsum(fds('i))+22).show().run()","fds.agg(fsum(fds('i)),","fds.filter(fds('i)","fds.select(fsum(fds('i)))","fds:","few","field","fields.","file","file.","filter","filteredd","filteredds.explain()","filteredds.show()","filteredds:","find","first","first()","first,","first_value)","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo,","foo.","format","format:","found","frameless","frameless'","frameless,","frameless.functions.aggregate.{sum","frameless.functions.aggregate.{sum=>fsum}","frameless.syntax._","frameless.typedaggregate[foo,?]","frameless.typedcolumn[foo,?]","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[mydate]","frameless:","friend.","fsum}","fulli","function","function(s)","function.","futur","generated.","get.;;","give","given","goal:","great!","group","guard","handhold","help","here","here.","hold","however,","implement","implicit","import","improv","incompat","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inmemoryfileindex[file:/tmp/foo],","input","insid","instanti","instead.","int)","introduc","intuitively,","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date(system.currenttimemillis))))","java.util.date)","j|","know","last","lead","let'","limit","line","linux","load","location:","long","long,","look","mac","make","map","member","members.","mention","method","mistak","mix","more","mydat","mydate(jday:","name","name:","need","newinstance(class","next","nil","non","note","notifi","now,","obj#1803:","obj#1804:","ok","on","oper","operations,","optim","optimizer)","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.analyzer.failanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:88)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$9.apply(checkanalysis.scala:280)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$checkanalysis$class$$anonfun$$checkvalidaggregateexpression$1$5.apply(checkanalysis.scala:253)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:280)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.org$apache$spark$sql$catalyst$analysis$checkanalysis$class$$anonfun$$checkvalidaggregateexpression$1(checkanalysis.scala:239)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.org$apache$spark$sql$catalyst$analysis$checkanalysis$class$$anonfun$$checkvalidaggregateexpression$1(checkanalysis.scala:253)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.failanalysis(checkanalysis.scala:39)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:71)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$6.apply(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1$1.apply(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$transformexpressionsup$1.apply(queryplan.scala:268)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:289)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:268)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1$$anonfun$10.apply(scalareflection.scala:614)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1$$anonfun$10.apply(scalareflection.scala:626)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1.apply(scalareflection.scala:455)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1.apply(scalareflection.scala:614)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1.apply(scalareflection.scala:632)","org.apache.spark.sql.catalyst.scalareflection$.cleanupreflectionobjects(scalareflection.scala:39)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:455)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:444)","org.apache.spark.sql.catalyst.scalareflection$class.cleanupreflectionobjects(scalareflection.scala:809)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:70)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:289)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:127)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:187)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:288)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:67)","org.apache.spark.sql.dataset.(dataset.scala:165)","org.apache.spark.sql.dataset.(dataset.scala:171)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2884)","org.apache.spark.sql.dataset.select(dataset.scala:1150)","org.apache.spark.sql.dataset.select(dataset.scala:1210)","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:275)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:52)","org.apache.spark.sql.functions.sum","org.apache.spark.sql.lowprioritysqlimplicits$class.newproductencoder(sqlimplicits.scala:233)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:33)","os","paramet","parquet","parquet,","partial","partitionfilters:","pass","performance.","physic","plan","plan,","plan.","plan:","polymorph","popular","practic","primit","problem","problem.","problemat","product","product,","project","projections/selections.","provid","pushedfilters:","queri","quick","q|","read","readschema).","readschema:","refer","relation[i#1771l,j#1772]","releases.","remind","requir","required:","resolv","result","return","root","run","runtim","safe","safe.","safety!","safety.","save","scala","scala.","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala.reflect.internal.tpe.typeconstraints$undolog.undo(typeconstraints.scala:56)","scala>","schema","second,","see","select","select()","sense,","separately,","sequenc","serial","serv","set","shapeless.tag.tagged[string(\"x\")]","show","similarly,","simpl","simplist","slow","small","solut","solv","spark","spark'","spark.","spark.createdataset(","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark:","sparksess","standard","start","statement","statement).","store","string)","string,","string]","struct","subset","such","suffici","suggests,","sum","sum(i)#1889l,","support","symbol","syntax","syntax.","take","thing","this.","time","time.","time:","togeth","tri","true,","tutori","two","two.","type","type.","type;","typedaggreg","typedcolumn","typeddataset","typeddataset.","typeddataset.create(ds)","typeddataset.create(seq(mydate(new","unabl","unfortunately,","us","val","valu","value#1805l]","veri","view","vs","want","way","well","window","without","work","wrap","w|","x","x:","|","|100|","|133|","|value|"],"TypedEncoder.html":["\"s\"))))","\"s\",","(a","(and","//","2.0)",":24:",":28:",":30:","=","[i:","^","annoy","approach","around","b:","bar","bar(1.1,","bar(d:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","behav","besid","call","care","case","class","classes.","code","compil","construct","coupl","current","custom","data","data.","dataset","dataset?.","dataset[daterange]","daterange(s:","decod","defin","deriv","derived,","detect","different,","double,","ds.collect()","ds:","e:","encod","encoder.","encoder:","encoders,","ensur","error","error:","exampl","example,","exist","expected:","extend","fail","find","follow","foo","foo(i:","foodate(i:","found:","frameless","frameless.job$$anon$4@558c6c17","frameless.job[seq[foo]]","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless:","gener","goe","hierarchi","ident","implicit","implicitli","import","inabl","int,","intern","introduc","issues.","java.util.d","java.util.date)","java.util.date)))","java.util.date))))","java.util.date,","jvm","lead","limit","manipul","mechan","method","more","new","non","note","object","of)","onc","org.apache.spark.sql.dataset","overflow","paramet","pass","performance.","prove","question","recurs","reflect","represent","res2:","resolut","run","runtim","runtime.","s:","same","scala>","scalareflect","schema.","see","shapeless'","shown","situat","solv","spark","spark'","spark.implicits._","spark:","sqlcontext","sqlcontext.createdataset(seq(daterange(new","stack","standard","store","string)","string,","struct]","summari","support","t:","take","through","time,","time.","time:","trace,","tri","type","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeencod","types.","us","val","valu","vanilla","won't","work"],"Injection.html":["$anon$1@37f23430","//","1","15:18:58","18","2","2018))","3",":23:",":31:","=","=>","[age:","^","a):","again","anoth","apply(a:","apply(d:","available,","b","b):","b.","b]","bigint]","birthday:","can't,","case","class","class:","compil","creat","custom","d.gettime()","datetolonginject","datetolonginjection:","def","defin","definit","encod","encoder:","error.","error:","exampl","extend","family:","feb","femal","find","frameless._","frameless.injection$$anon$1@4d1cf7ad","frameless.injection$$anon$1@6cd20faa","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.typeddataset[person]","frameless.typedencoder[person]","function:","gender","gender)","gender:","gendertoint:","implicit","import","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","instanc","int,","int]","invert(b:","invert(l:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date)","java.util.date))","java.util.date).gettime(),","java.util.date):","java.util.date.","less","let","let'","list(person(42,male))","list(person(42,sun","long","long)))","long):","long:","long]","look","male","male))","more","new","now","object","on","paramet","peopl","people:","person","person(age:","persond","personds:","precis","pst","seal","seq(person(42,","seq[person]","serializ","simpl","trait","tri","type","type,","typeclass:","typeddataset,","typeddataset.create(people)","typeddataset:","typedencod","us","val","valu","verbos","{","}","})","},"],"Job.html":["(a","(sample:","//","1","20%","20)","=","=>","[_1:","abil","above)","above,","allow","along","annotate/nam","applic","be","block","calcul","call","captur","cat","cats.effect.sync","collect","compar","complex","compos","composit","comprehens","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","constructor","count","countandtakejob","data","def","default","description.","differ","driver","ds","ds:","easier","effect","effects.","element","elements:","exactli","exampl","example,","execut","expens","explicit","explicitli","f[_]","f[a]","f[a],","few","finaljob","finaljob.","finaljob:","first","frameless.","frameless.job","frameless.job$$anon$2@30c69a34","frameless.job[int]","frameless.job[seq[int]])frameless.job[int]","frameless.syntax._","frameless.typeddataset[int]","functions:","further","group","have","help","id","implement","implicitli","import","inform","instanc","instance.","int","int]","issues.","job","job[a]","job[int]","job[seq[int]]):","jobs.","lazi","lazili","lazy,","lazy.","make","mention","min\").","module,","monad","more","new","non","now","obviou","open","oper","order","part","pass","perform","place","predict","program","programm","provid","repres","requir","res2:","result","return","run","run()","sample.map(_.min)","say,","see","sequenc","serv","sever","show","showcas","size","spark","spark.","sparkdelay","sparkdelay[f[_]]","sparksession.","specifi","strict","such","support","suspend","suspens","thunk","toy","track","track,","transform","type","typeclass","typeclass,","typeddataset","typeddataset.create(1","ui","us","user","val","value,","via","withdescription(\"sampl","withgroupid(\"samplingjob\").","{"],"Cats.html":["\"another\")))","\"string\"),","\"task2\"","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(0,0,0)","(1,","(1,2,3)","(10,9,9)","(2,","(8,","(8,2,3)","(and","(chris,map(0","(john,map(0","(sam,map(0","(semigroup)","(seq[(int,","(wrappedarray((1,string)),2)",")","//","1","1)","1))","1)),","1),","1,","10))","10,","100)","11))","12)","12,","15)))","2","2)","2))","2)),","2,","20)","20,","3)","3))","3,","32,","4))","4)),","4,","5,","6,",":44",":46",":47",":50","::","=",">","[_1:","_2:","abil","above.","abstract","action","action[(seq[(int,","action[t]","aggreg","algebra","alia","alias","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","anna","api","arbitrari","arity.","array((joe,map(0","array[(username,","assum","avg,","be","below","block","capabl","captur","case","cat","cats.data.readert","cats.effect.implicits._","cats.effect.io","cats.effect.sync[f].","cats.implicit","cats.implicits._","cats.mtl.implicits._","cats:","class","cmax","cmin","collect","column","combin","common","complex","comput","constructor","conveni","counterpart","csum,","data","data.","data:","dataset","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","deal","default","defin","delay","descript","description:","differ","effect","effect:","effects.","element","empti","empty,","emptyrdd","emptyrdd[15]","enhanc","enrich","etc.","exampl","example,","example:","execut","exist","f[_]","f[_],","fanci","first","follow","frameless","frameless.cats.implicits.","frameless.cats.implicits._","frameless.cats.implicits._.","frameless.cats.outer._","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[(int,","frameless:","full","general).","given","group","implicit","implicits.scala:42","implicits.scala:67","import","insid","instanc","int","int)]","int,","integr","io","job,","joe","join","kernel","key","key.","keys.","larg","layer","lazy.","leverag","library:","local","long)","long)]","machineri","main","makerdd","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[25]","mapvalu","max,","meaning","method","min,","modifi","module,","monad","more","mtl","namely,","need","nil","nil)","none","normal","note","noth","now,","offer","on","oper","option","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","outer","over","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","pair","parallelcollectionrdd[14]","parallelcollectionrdd[16]","parallelcollectionrdd[18]","parallelcollectionrdd[20]","parallelcollectionrdd[21]","part","plain","pre","predicates.","previous","println(data.cmax)","println(data.cmaxoption)","println(data.cmin)","println(data.cminoption)","println(data.csum)","println(data.csumoption)","program,","properli","provid","r","rdd","rdd.","rdd:","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","readert","readert[io,","reducebykey","repres","request","res16:","res17:","res19:","res20:","res5:","res6:","result","result.run(spark).unsaferunsync()","result:","resultwithdescription.run(spark).unsaferunsync()","resultwithdescription:","return","run","run:","same","sampl","sc.emptyrdd","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala.collection.immutable.sortedmap","scala.collection.immutable.sortedmap[string,int])]","scala.collection.map[string,scala.collection.immutable.sortedmap[string,int]]","scala.collection.map[user,transactioncount]","section","semigroup","set","show","shuffledrdd[17]","shuffledrdd[19]","simplifi","sort","sortedmap(\"task1\"","sortedmap(\"task3\"","spark","sparkdelay","sparkdelay[f].","sparksess","sparksession,","sparksession.","stack","stack.","stack:","string","string)]","string)],","string]","suppli","suspend","suspended.","suspens","syntax","t]","task","task2","task3","those","thread","timeseri","timeseries)]","togeth","together.","totalperus","totalperuser.collectasmap","totalperuser:","transactioncount","transactioncount)]","tupl","two","type","type.","typeclass","typedd","typeddataset","typeddataset.create(seq((1,","typedds:","us","user","user'","usernam","util","val","valu","variabl","way","work","work,","wrap","yet.","{","|+|"],"TypedML.html":["\"\",","\"lyon\",","\"san","(0","(empti","(name","(repres","(see","(the","(what","(which",")","))","...",".as[housedatawithfeatures]","//","0)))","1","1,","1.0","100000)))","100000),","1:","2","2))","2,","2.0","200000),","250000),","2:","3","3)","4","500000)","500000),","800000)))","900000)",":)",":37:",":39:","=",">","[1.0,2.0,3.0]","[_1:","[features:","[squarefeet:","^","_2:","abov","abstract","accept","add","another,","api","api,","append","array","array(1,","as:","assembl","assembler.transform(testdata).as[housedatawithfeatures]","assembler.transform(trainingdata)","assembler.transform(trainingdata).as[housedatawithfeatures]","assembler.transform(trainingdata).as[wronghousefeatures]","assembler.transform(wrongtrainingdata)","assembler:","back","base","boolean","boolean)","boolean,","boolean:","both","call","calls,","case","case)","cast","categor","check","citi","city.","city:","cityindexed:","class","close","code","column(s)","column(s).","companion","compil","comput","contain","continu","contrari","contribut","correct","current","data","data)","data,","datafram","datawithfeatur","datawithfeatures:","deal","default","defin","depend","deriv","detail","document","doubl","double)","double,","double]","encod","equival","error:","estimator.","estimators.","exampl","example,","exclus","fact","false,","featur","features(price:","features(squarefeet:","features).","features):","features.","features:","feed","field","field]","fields]","find","fit","footag","footage.","forest,","frameless","frameless._","frameless.ml._","frameless.ml.appendtransformer[rfinputs,frameless.ml.classification.typedrandomforestclassifier.outputs,org.apache.spark.ml.classification.randomforestclassificationmodel]","frameless.ml.appendtransformer[rfinputs,frameless.ml.regression.typedrandomforestregressor.outputs,org.apache.spark.ml.regression.randomforestregressionmodel]","frameless.ml.appendtransformer[stringindexerinput,frameless.ml.feature.typedstringindexer.outputs,org.apache.spark.ml.feature.stringindexermodel]","frameless.ml.classification._","frameless.ml.classification.typedrandomforestclassifier@be7ee","frameless.ml.classification.typedrandomforestclassifier[rfinputs]","frameless.ml.feature._","frameless.ml.feature.typedindextostring@c97d749","frameless.ml.feature.typedindextostring[indextostringinput]","frameless.ml.feature.typedstringindexer@666bcbec","frameless.ml.feature.typedstringindexer[stringindexerinput]","frameless.ml.feature.typedvectorassembler@159b3f1","frameless.ml.feature.typedvectorassembler@66b12f1","frameless.ml.feature.typedvectorassembler[features]","frameless.ml.regression._","frameless.ml.regression.typedrandomforestregressor@4c620c93","frameless.ml.regression.typedrandomforestregressor[rfinputs]","frameless.ml.typedestimator$$anonfun$fit$1$$anon$1@20355c2f","frameless.ml.typedestimator$$anonfun$fit$1$$anon$1@36ed2d44","frameless.ml.typedestimator$$anonfun$fit$1$$anon$1@5a0797","frameless.ops.as[(double,","frameless.syntax._","frameless.typeddataset[(string,","frameless.typeddataset[housecityprediction]","frameless.typeddataset[housecitypredictionindexed]","frameless.typeddataset[housecitypredictioninputs]","frameless.typeddataset[housedata]","frameless.typeddataset[housedatawithfeatures]","frameless.typeddataset[housedatawithfeaturesandindex]","frameless.typeddataset[housepriceprediction]","frameless.typeddataset[wronghousedata]","francisco\",","francisco)","from)","garden","hasgarden","hasgarden:","here","hood,","hous","housecitypredict","housecityprediction(","housecitypredictionindex","housecitypredictionindexed(","housecitypredictioninput","housecitypredictioninputs(features:","housedata","housedata(100,","housedata(150,","housedata(20,","housedata(200,","housedata(50,","housedata(squarefeet:","housedata?","housedatawithfeatur","housedatawithfeatures(squarefeet:","housedatawithfeaturesandindex","housedatawithfeaturesandindex(","housepricepredict","housepriceprediction(","i.","ignor","implement","implicit","import","index","indexeddata","indexeddata:","indexedpredict","indexedpredictions:","indexedtestdata","indexedtestdata.project[housecitypredictioninputs]","indexedtestdata:","indexer.fit(datawithfeatures).run()","indexer:","indexermodel","indexermodel.transform(datawithfeatures).as[housedatawithfeaturesandindex]","indexermodel.transform(testdatawithfeatures).as[housedatawithfeaturesandindex]","indexermodel:","indextostr","indextostring.transform(indexedpredictions).as[housecityprediction]","indextostring:","indextostringinput","indextostringinput(predictedcityindexed:","input","instanc","int,","introduc","it.","label","label)","label):","label,","level","leverag","list","locat","lowest","make","matrices.dense(2,","matrix","matrix))","matrix:","matrix]","matrixd","matrixds:","member","method","miss","ml","ml'","model","model.","model.transform(testdata)","model.transform(testdatawithfeatures)","model.transform(testdatawithfeatures).as[housepriceprediction]","model.transform(testinput).as[housecitypredictionindexed]","model:","modul","more","moreover,","name","need","new","not.","now","numer","object.","on","order","org.apache.spark.ml.linalg._","org.apache.spark.ml.linalg.matrix","org.apache.spark.ml.linalg.matrix)]","org.apache.spark.ml.linalg.matrix:","org.apache.spark.ml.linalg.matrixudt.","org.apache.spark.ml.linalg.vector","org.apache.spark.ml.linalg.vector),wronghousefeatures]","org.apache.spark.ml.linalg.vector)]","org.apache.spark.ml.linalg.vectorudt","org.apache.spark.sql.types.userdefinedtype[a]","overview):","paramet","pass","perhap","pleas","possibl","predict","predict).","predictedcity:","predictedcityindexed.","predictedcityindexed:","predictedprice:","predictions.select(predictions.col('predictedcity)).collect.run()","predictions.select(predictions.col('predictedprice)).collect.run()","predictions:","previou","previous","price","price:","probability:","project","prove","provid","random","rawprediction:","repres","res6:","res8:","return","reus","rf","rf.fit(indexeddata).run()","rf.fit(trainingdatawithfeatures)","rf.fit(trainingdatawithfeatures).run()","rf.fit(wrongtrainingdatawithfeatures)","rf:","rfinput","rfinputs(cityindexed:","rfinputs(price:","rfinputs.","safe","safeti","sale","same","seq[double]","seq[string]","snippet,","spark","spark).","squar","squarefeet:","stay","string","string)","string,","stringindexerinput","stringindexerinput(city:","strongli","structur","subsequ","take","term","test","testdata","testdata.","testdata:","testdatawithfeatur","testdatawithfeatures:","testinput","testinput:","thank","then,","time","time.","train","trainingdata","trainingdata:","trainingdatawithfeatur","trainingdatawithfeatures:","transform","true,","type","type.","typeddataset","typeddataset'","typeddataset.","typeddataset.create(seq(","typeddataset.create(seq(\"label\"","typeddataset.create(seq(housedata(120,","typeddataset.create(seq(housedata(20,","typeddataset.create(seq(housedata(70,","typeddataset.create(seq(wronghousedata(20,","typeddataset:","typeddatasets.","typedencod","typedencoder[a]","typedestim","typedestimator,","typedestimators,","typedindextostr","typedindextostring[indextostringinput](indexermodel.transformer.labels)","typedrandomforestclassifi","typedrandomforestclassifier.","typedrandomforestclassifier[rfinputs]","typedrandomforestregressor","typedrandomforestregressor.","typedrandomforestregressor[rfinputs]","typedrandomforestregressor[wrongrfinputs]","typedstringindex","typedstringindexer[stringindexerinput]","typedtransform","typedtransformercan","typedvectorassembl","typedvectorassembler[features]","typedvectorassembler[wrongfeatures]","types)","types,","types.","under","us","usual","val","valid","valu","vector","vector)","vector))","vector,","vector:","vector]","vectorassembl","vectorassembler)","vectorassembler.transform(testdata).as[housedatawithfeatures]","vectorassembler.transform(trainingdata).as[housedatawithfeatures]","vectorassembler:","vectord","vectords:","vectors.dense(1,","vectors:","veri","want","wrappedarray(420000.0)","wrappedarray(san","wrong","wrongfeatur","wrongfeatures(squarefeet:","wronghousedata","wronghousedata(squarefeet:","wronghousedata?","wronghousefeatures(","wrongrfinput","wrongrfinputs(labelofwrongtype:","wrongtrainingdata","wrongtrainingdata:","wrongtrainingdatawithfeatur","wrongtrainingdatawithfeatures:"],"TypedDataFrame.html":["\"dummy\"","\"unique\"","').map(r","'_4)","'q',","'s)","'x',","'z'))","'z'.","(((((((((","(implicit","(phonebooktf:",")",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","//","1.6","1.6+,","1.6,","11","2.10,","2.11","2.11,","22.",":",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","=>","???","addit","address","address,","address:","alphabet:","alternatively,","amount","api","approach","approxim","ariti","avail","away:","b:","bar(i:","bestneighborhood","boolean","boolean)","boolean):","boolean)]","boolean,","both","bring","c:","call","case","catch","caught","caus","citi","citymapentry(","citymaptf:","class","column","columns.","come","common","commonli","compar","compat","compil","complet","comput","concept:","consid","consist","contain","conveni","correct","count:","d:","data","datafram","dataframe,","dataframes,","dataset","def","defin","definit","deprec","design","develop","differ","directli","dive","document.","domain","done","doubl","double,","due","each","earli","element","enough","ensur","essenti","everyth","exampl","example:","except","execut","exist","expect","f","f.neighborhood))","f.residents.split('","fact","family(residents:","field","filter(conditionexpr:","first","flat","focu","follow","foo(s:","frameless","frameless.","frameless.typeddatafram","frameless:","function","further","futur","get","go","goal","goe","handl","have","here","hold","however,","i:","ident","import","improv","inform","instead","int)","int,","interest","intermedi","introduc","introduct","invalid","j:","job","jobs.","join","join1(tf1:","join2(tf1:","joins,","keep","languag","less","let","let'","letter","level","leverag","librari","like,","limit","limitations.","line","long)","long)])","look","main","manag","manipul","manner.","map","mirror","mistak","model","moder","more","much","name","name.exists(set('x',","names,","natur","need","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","neighborhoods:","nlplib","nlplib.uniquename(p.name)","now","number,","object","obtain","ontypeddataframe.","onward.","org.apache.spark.sql.datafram","org.apache.spark.sql.sqlcontext","p","packag","pair","person(name:","person(r,","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","point,","possibl","process","product.","proof","provid","public","readability.","readabl","reasons,","refer","referenc","represent","residents:","result","rethought","return","right","sadly,","safe","safety.","scala","schema","schema.","second","see","see,","seem","select","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","shadow","shapeless.hlist","signatures:","similar","simplifi","singl","spark","spark'","spark,","sqlcontext):","stage","still","store","string","string):","string)]","string)])","string,","suppos","syntax","syntaxes.","system","systems,","tabl","table,","tables:","target","tdataframe[schema","tdataframe[schema]","techniqu","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","time.","track","troubl","tuple23","two","type","type,","type.","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry])","typeddataframe[citymapentry].","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","types:","typo,","uniqu","uniquename(name:","us","user","valu","vanilla","variou","veri","version","way","well,","won't","work","zero.","{","}"]},"length":9},"tokenStore":{"root":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"1":{"3":{"docs":{},".":{"1":{"3":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"docs":{}},"docs":{}}},"docs":{}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"4":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"1":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"docs":{}}},"5":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"docs":{}}},"docs":{}},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"1":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"i":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"docs":{},":":{"1":{"8":{"docs":{},":":{"5":{"8":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"8":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.010282776349614395},"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}},".":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"1":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}},"docs":{}}},"1":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"6":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"+":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"docs":{}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.007712082262210797},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},")":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"docs":{}},"docs":{}},"docs":{}},"1":{"8":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"docs":{}},"docs":{},"%":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"4":{"0":{"9":{"docs":{},".":{"6":{"3":{"8":{"5":{"5":{"4":{"2":{"1":{"6":{"8":{"6":{"7":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},")":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"9":{"5":{"5":{"docs":{},".":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006201550387596899},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"1":{"0":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{},"x":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}},"2":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}},"1":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"docs":{}}},"3":{"docs":{},".":{"2":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"docs":{}}},"docs":{}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},"#":{"1":{"8":{"9":{"0":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0031007751937984496}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"4":{"3":{"6":{"2":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"4":{"3":{"0":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"9":{"1":{"docs":{},".":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"4":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"docs":{}},"docs":{}},"7":{"1":{"5":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"6":{"8":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"7":{"4":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"7":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"docs":{}},"docs":{}},"8":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"5":{"4":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"\"":{"0":{"docs":{},".":{"5":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"docs":{}}},"docs":{}}},"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.008595988538681949}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.008595988538681949}}}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"q":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"w":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"a":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"2":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"docs":{}}}}},"\"":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"d":{"docs":{},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"y":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"%":{"docs":{"./":{"ref":"./","tf":0.008595988538681949}},"%":{"docs":{"./":{"ref":"./","tf":0.008595988538681949}}}},"(":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"0":{"docs":{},",":{"0":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}}},"docs":{}}},"docs":{}}},"1":{"0":{"docs":{},",":{"9":{"docs":{},",":{"9":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}}},"docs":{}}},"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"2":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"8":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},",":{"docs":{"./":{"ref":"./","tf":0.008595988538681949}}}}}},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"y":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}},"t":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"#":{"1":{"7":{"7":{"1":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"1":{"7":{"7":{"1":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355}}}}},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"1":{"6":{"6":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"e":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"q":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{}}}}}}}}},"u":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"a":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"docs":{}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"\"":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}}}}}},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998}}}}},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998},"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"+":{"1":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.1},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.03985507246376811}},"+":{"docs":{},"=":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"=":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.025968992248062015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010869565217391304},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.029411764705882353},"Injection.html":{"ref":"Injection.html","tf":0.06329113924050633},"Job.html":{"ref":"Job.html","tf":0.029411764705882353},"Cats.html":{"ref":"Cats.html","tf":0.042416452442159386},"TypedML.html":{"ref":"TypedML.html","tf":0.04838709677419355},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0166358595194085}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.009057971014492754}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005434782608695652}}}},">":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}}},">":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.05141388174807198},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"=":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}},"p":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}},"e":{"docs":{},"l":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005434782608695652},"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"g":{"docs":{},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}},"i":{"docs":{"./":{"ref":"./","tf":0.011461318051575931},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}}},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"s":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"c":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"d":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"n":{"docs":{},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"t":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}},"s":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},".":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"3":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}},"y":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}}},"2":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"(":{"1":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{},"(":{"docs":{},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"[":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"4":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}},")":{"docs":{},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"o":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"i":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"n":{"docs":{},"o":{"docs":{},"y":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"b":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"docs":{}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}},"docs":{}}},"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}},"c":{"docs":{},"k":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"s":{"docs":{},"#":{"5":{"6":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"'":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}},"3":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.00564516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"s":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0034883720930232558},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"(":{"1":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"docs":{}},"2":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"docs":{}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006201550387596899},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004528985507246377},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.02287581699346405},"Injection.html":{"ref":"Injection.html","tf":0.04113924050632911},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.01532258064516129},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.018484288354898338}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.017191977077363897},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":3.3487574978577546}},"s":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"e":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"[":{"docs":{},"f":{"docs":{},"]":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}},"o":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}},"m":{"docs":{},"t":{"docs":{},"l":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"r":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}}}}}},"o":{"docs":{},"o":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.009302325581395349},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008152173913043478},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03594771241830065},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.028225806451612902},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.022181146025878003}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008527131782945736},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008152173913043478},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012939001848428836}},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"(":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5018115942028984},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.011461318051575931},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008152173913043478},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.013071895424836602},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"x":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984},"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}}}}}},"o":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351817621688227}}}}}},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"o":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"o":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.00564516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"u":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"n":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"p":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Injection.html":{"ref":"Injection.html","tf":2.5126582278481013}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Injection.html":{"ref":"Injection.html","tf":2.5031645569620253}},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}}}}}},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}}}}},"docs":{}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedML.html":{"ref":"TypedML.html","tf":0.008064516129032258}}},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"2":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"1":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"3":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"docs":{}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"3":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"4":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.00564516129032258}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"1":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"3":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"4":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.02005730659025788},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5081521739130435},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"\"":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"/":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"?":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012939001848428836}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}},"y":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.02005730659025788},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}}}}}},"f":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014787430683918669}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Injection.html":{"ref":"Injection.html","tf":0.03481012658227848},"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998},"TypedML.html":{"ref":"TypedML.html","tf":0.013709677419354839},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0196078431372549},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0031007751937984496},"TypedML.html":{"ref":"TypedML.html","tf":0.007258064516129033},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"TypedML.html":{"ref":"TypedML.html","tf":0.028225806451612902},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"]":{"docs":{},"|":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"(":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"/":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}},"_":{"docs":{},".":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.026143790849673203},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"u":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005434782608695652},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.352941176470588},"Injection.html":{"ref":"Injection.html","tf":2.5126582278481013},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"s":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"t":{"docs":{},"i":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006340579710144928},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.013071895424836602},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355}}}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"s":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"i":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"o":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},".":{"docs":{},"g":{"docs":{},".":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"[":{"1":{"5":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"docs":{}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"i":{"docs":{},",":{"1":{"0":{"docs":{},")":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}},"docs":{}},"docs":{}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"$":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}}}}}}},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"t":{"docs":{},"c":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.007712082262210797}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3337209302325577},"TypedML.html":{"ref":"TypedML.html","tf":0.010483870967741936}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.00967741935483871}}}}}}}}},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"w":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"b":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004263565891472868},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"TypedML.html":{"ref":"TypedML.html","tf":0.008870967741935484},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0034883720930232558},"TypedML.html":{"ref":"TypedML.html","tf":0.007258064516129033}}}}}}},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}}}}}}},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006340579710144928},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"c":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.06303724928366762},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3431372549019605},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}}}}}}}}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"?":{"docs":{},"t":{"docs":{},",":{"docs":{},"?":{"docs":{},"c":{"docs":{},"[":{"docs":{},"?":{"docs":{},"a":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"t":{"docs":{},",":{"docs":{},"c":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"c":{"docs":{},"]":{"docs":{},")":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"[":{"docs":{},"t":{"docs":{},",":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"{":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"=":{"docs":{},">":{"docs":{},"f":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"}":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"?":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"?":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"t":{"docs":{},"t":{"docs":{},"]":{"docs":{},"{":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"2":{"docs":{},"@":{"3":{"0":{"docs":{},"c":{"6":{"9":{"docs":{},"a":{"3":{"4":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"4":{"docs":{},"@":{"5":{"5":{"8":{"docs":{},"c":{"6":{"docs":{},"c":{"1":{"7":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},"_":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"4":{"docs":{},"d":{"1":{"docs":{},"c":{"docs":{},"f":{"7":{"docs":{},"a":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"docs":{}}}},"docs":{}}},"6":{"docs":{},"c":{"docs":{},"d":{"2":{"0":{"docs":{},"f":{"docs":{},"a":{"docs":{},"a":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"docs":{}},"docs":{}}}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"@":{"docs":{},"b":{"docs":{},"e":{"7":{"docs":{},"e":{"docs":{},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"docs":{}}}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"@":{"docs":{},"c":{"9":{"7":{"docs":{},"d":{"7":{"4":{"9":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"@":{"6":{"6":{"6":{"docs":{},"b":{"docs":{},"c":{"docs":{},"b":{"docs":{},"e":{"docs":{},"c":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"@":{"1":{"5":{"9":{"docs":{},"b":{"3":{"docs":{},"f":{"1":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"6":{"6":{"docs":{},"b":{"1":{"2":{"docs":{},"f":{"1":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"[":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"@":{"4":{"docs":{},"c":{"6":{"2":{"0":{"docs":{},"c":{"9":{"3":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"2":{"0":{"3":{"5":{"5":{"docs":{},"c":{"2":{"docs":{},"f":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"6":{"docs":{},"e":{"docs":{},"d":{"2":{"docs":{},"d":{"4":{"4":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"docs":{}},"docs":{}}},"docs":{}}}},"docs":{}},"5":{"docs":{},"a":{"0":{"7":{"9":{"7":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},"e":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"o":{"docs":{},"m":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"l":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"f":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},"+":{"2":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"f":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"}":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"[":{"docs":{},"_":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"a":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},".":{"docs":{},";":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"l":{"docs":{},")":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015822784810126583}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}}},"t":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"8":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"docs":{}}},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"b":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}},"o":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"a":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"?":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"o":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"u":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"s":{"docs":{},"(":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"docs":{}},"2":{"0":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"docs":{}},"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}},"?":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"v":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"s":{"docs":{},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.00967741935483871}}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"s":{"docs":{},"/":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}},"docs":{}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.013071895424836602},"Injection.html":{"ref":"Injection.html","tf":0.015822784810126583},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"l":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"docs":{}},"6":{"7":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{}},"docs":{}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008914728682170543},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01177536231884058},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.016339869281045753},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.032133676092544985},"TypedML.html":{"ref":"TypedML.html","tf":0.008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015822784810126583}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"Injection.html":{"ref":"Injection.html","tf":2.5031645569620253}}},"(":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"n":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"g":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"t":{"docs":{"./":{"ref":"./","tf":10},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.007258064516129033}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"[":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"l":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"f":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"t":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}},"o":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"l":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.013071895424836602}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0196078431372549}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"y":{"docs":{},"r":{"docs":{},"s":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"Job.html":{"ref":"Job.html","tf":10.004201680672269}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"i":{"docs":{},"n":{"1":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}}}}},"2":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.011090573012939002}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"v":{"docs":{},"m":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"e":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"s":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}}}}},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.011461318051575931}}}}}},"s":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"(":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}},"s":{"docs":{},"u":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}},"f":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"t":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"0":{"1":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}},"docs":{}},"docs":{}}},"1":{"docs":{},".":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"docs":{}}},"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}},"b":{"docs":{},"c":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"u":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"o":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"a":{"docs":{},"z":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"y":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"r":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"8":{"2":{"docs":{},".":{"5":{"9":{"7":{"0":{"5":{"4":{"8":{"8":{"6":{"2":{"1":{"1":{"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"m":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"r":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998}}}}}}},"n":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"2":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}}}}}}}}}}},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.007712082262210797}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}},"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"docs":{}}}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"2":{"5":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"l":{"docs":{},"e":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"x":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}}},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}}},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},"f":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"u":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"l":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"TypedML.html":{"ref":"TypedML.html","tf":2.511290322580645}},"\"":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"'":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.011461318051575931},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005426356589147287},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.012096774193548387},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}}}}},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},"e":{"docs":{},"(":{"docs":{},"j":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.02287581699346405},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}},"x":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"t":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"h":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"l":{"docs":{},"l":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"s":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"v":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},"(":{"1":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},",":{"4":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"c":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"Cats.html":{"ref":"Cats.html","tf":0.010282776349614395}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}},"n":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}}}}}}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.007246376811594203}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3337209302325577}},")":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"$":{"2":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"9":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"0":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"$":{"5":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"5":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"0":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"7":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"8":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"5":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"6":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"1":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"9":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"$":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"1":{"0":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"1":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"2":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"5":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"6":{"1":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"3":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"5":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"4":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"0":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"$":{"docs":{},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"$":{"docs":{},"$":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"1":{"5":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"2":{"1":{"0":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"6":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"7":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"$":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"{":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},".":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"g":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},")":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"u":{"docs":{},"d":{"docs":{},"t":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},")":{"docs":{},",":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"u":{"docs":{},"d":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"8":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"b":{"docs":{},"j":{"docs":{},"#":{"1":{"8":{"0":{"3":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745},"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"l":{"docs":{},"y":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.012096774193548387}},")":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0031007751937984496},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"i":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"n":{"docs":{},"s":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"o":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351817621688227}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355}},"#":{"5":{"5":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"/":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0034883720930232558},"TypedML.html":{"ref":"TypedML.html","tf":0.007258064516129033}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"b":{"docs":{},"y":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"3":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"4":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"6":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"8":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"2":{"0":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"1":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"i":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010869565217391304}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"i":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}},"(":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519}},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}},"i":{"docs":{},"v":{"docs":{},"o":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005434782608695652}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"t":{"docs":{},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004528985507246377}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"c":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"s":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"d":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"Cats.html":{"ref":"Cats.html","tf":3.33847472150814}},"s":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"i":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}},"a":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004528985507246377}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"[":{"docs":{},"i":{"docs":{},"o":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"u":{"docs":{},"i":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"s":{"1":{"6":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"9":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"2":{"0":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"9":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"3":{"0":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"5":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"5":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"8":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"u":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"#":{"1":{"7":{"7":{"1":{"docs":{},"l":{"docs":{},",":{"docs":{},"j":{"docs":{},"#":{"1":{"7":{"7":{"2":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"u":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"e":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004263565891472868}}},"o":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"f":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}},"m":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}}},"p":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"y":{"docs":{},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"l":{"docs":{},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"d":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.011461318051575931}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"5":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"9":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},".":{"docs":{},"t":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"$":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},">":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},".":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"'":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"(":{"1":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"7":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"9":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"docs":{}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"y":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"z":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.022922636103151862},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010869565217391304},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Job.html":{"ref":"Job.html","tf":0.03361344537815126},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198},"TypedML.html":{"ref":"TypedML.html","tf":2.5080645161290325},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.018484288354898338}},"'":{"docs":{"./":{"ref":"./","tf":0.011461318051575931},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.505434782608696},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},")":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},".":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"[":{"docs":{},"*":{"docs":{},"]":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"[":{"docs":{},"f":{"docs":{},"[":{"docs":{},"_":{"docs":{},"]":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"]":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}},"y":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"g":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.007258064516129033},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},",":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.012403100775193798},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014787430683918669}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"l":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"q":{"docs":{},"u":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},"#":{"1":{"8":{"8":{"9":{"docs":{},"l":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"#":{"5":{"4":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004263565891472868}}}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"[":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.012605042016806723}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"i":{"docs":{},"z":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}}},"3":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004528985507246377},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"s":{"docs":{},"k":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.00564516129032258}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"l":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"r":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}},"n":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"a":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.02005730659025788},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.009302325581395349},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.015398550724637682},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3464052287581696},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.02313624678663239},"TypedML.html":{"ref":"TypedML.html","tf":0.016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.027726432532347505}},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.344423906346272}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"p":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0034883720930232558},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.503623188405797},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198},"TypedML.html":{"ref":"TypedML.html","tf":2.504032258064516}},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"docs":{}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}},"docs":{}}}}}}}}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"\"":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"1":{"2":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"docs":{}},"2":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"7":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"docs":{}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"2":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519}}}}}}}}}}}}}}}}},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3344961240310074},"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"[":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}},"u":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"'":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"s":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},"s":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"s":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"a":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.013071895424836602}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004263565891472868}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}}},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.008870967741935484}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"2":{"3":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"docs":{}},"docs":{}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}},"w":{"docs":{},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}},"f":{"1":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"j":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"2":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"j":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}},"t":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}}}}}}}},"p":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{"./":{"ref":"./","tf":0.02005730659025788},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005434782608695652},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"Cats.html":{"ref":"Cats.html","tf":3.3423307626392456},"TypedML.html":{"ref":"TypedML.html","tf":2.511290322580645},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.009242144177449169}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"'":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"d":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.012790697674418604},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004528985507246377},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.02287581699346405},"Injection.html":{"ref":"Injection.html","tf":0.03481012658227848},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.015424164524421594},"TypedML.html":{"ref":"TypedML.html","tf":0.02338709677419355}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998},"TypedML.html":{"ref":"TypedML.html","tf":0.0064516129032258064},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"#":{"1":{"8":{"0":{"5":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"o":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.017191977077363897},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0064516129032258064}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.00967741935483871}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"a":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0034883720930232558},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}}}},"y":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"h":{"docs":{},"y":{"docs":{},"?":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}},"docs":{}}}}}}}}}}}},"/":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"]":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"]":{"docs":{},"(":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"4":{"2":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"(":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}},"docs":{}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}},"?":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"s":{"docs":{},"(":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"f":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"}":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"w":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"$":{"docs":{},"\"":{"docs":{},"*":{"docs":{},"\"":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"i":{"docs":{},"\"":{"docs":{},"*":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"1":{"4":{"docs":{},".":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"3":{"7":{"docs":{},"f":{"2":{"3":{"4":{"3":{"0":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}}}}}}},"'":{"docs":{},"`":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}},"x":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"`":{"docs":{},"i":{"docs":{},"`":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"_":{"4":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}},"q":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"z":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"*":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedML.html":{"ref":"TypedML.html","tf":0.014516129032258065}},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"*":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"'":{"docs":{},"_":{"2":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"_":{"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"docs":{}}}}}}},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.13178294573643412},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.12047101449275362},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.032679738562091505},"Injection.html":{"ref":"Injection.html","tf":0.06645569620253164},"Job.html":{"ref":"Job.html","tf":0.025210084033613446},"Cats.html":{"ref":"Cats.html","tf":0.05398457583547558},"TypedML.html":{"ref":"TypedML.html","tf":0.056451612903225805},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},":":{"2":{"0":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"3":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"5":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"9":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}},"docs":{}},"3":{"0":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"1":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"5":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}}}},"7":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}}}},"9":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"4":{"4":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"6":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"7":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{}},"5":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Cats.html":{"ref":"Cats.html","tf":0.02313624678663239}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"[":{"1":{"docs":{},".":{"0":{"docs":{},",":{"2":{"docs":{},".":{"0":{"docs":{},",":{"3":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{},".":{"docs":{},".":{"1":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"docs":{}},"docs":{}}}}},"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"x":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"_":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"docs":{}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"#":{"5":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005426356589147287}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"4":{"3":{"6":{"2":{"9":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"]":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}},"a":{"docs":{},"]":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}},"i":{"docs":{},"#":{"1":{"7":{"7":{"1":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},",":{"docs":{},"j":{"docs":{},"#":{"1":{"7":{"7":{"2":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"[":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}}}}}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"1":{"7":{"7":{"1":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.010483870967741936}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}}}}}}}}},"^":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005434782608695652},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355}}},"_":{"1":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004263565891472868},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}},"#":{"1":{"8":{"7":{"6":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0031007751937984496},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004263565891472868}}}},"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}}}},"4":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}},"{":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}},"|":{"1":{"0":{"0":{"0":{"docs":{},"|":{"1":{"0":{"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"3":{"3":{"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"7":{"6":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"6":{"2":{"docs":{},".":{"8":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"9":{"0":{"8":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"1":{"2":{"docs":{},".":{"5":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"8":{"docs":{},"|":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.01744186046511628},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008152173913043478}},"[":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"4":{"5":{"docs":{},",":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"8":{"3":{"docs":{},",":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"2":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"7":{"4":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"3":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"1":{"0":{"0":{"docs":{},",":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"2":{"5":{"docs":{},",":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"5":{"0":{"docs":{},",":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"|":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"b":{"docs":{},"c":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"+":{"docs":{},"|":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}}}},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"&":{"docs":{},"&":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"`":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},"`":{"docs":{},")":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"y":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"?":{"docs":{},"?":{"docs":{},"?":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"length":3292},"corpusTokens":["\"\",","\"0.5.0\"","\"abc\")","\"another\")))","\"dummy\"","\"e\")","\"false\")","\"frameless","\"java.util.date\",","\"jday\")","\"lyon\",","\"mydate\"","\"org.typelevel\"","\"paris\")","\"paris\",","\"q\")","\"s\"))))","\"s\",","\"san","\"string\"),","\"task2\"","\"unique\"","\"w\")","$\"*\".","$\"i\"*2)","$anon$1@37f23430","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","%","%%","&&","'(sum(`i`)","').map(r","'_4)","'`citi`'","'`i`'","'`x`'","'city),","'name),","'population)","'price),","'project","'q',","'s)","'x',","'z'))","'z'.","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(((((((((","(0","(0,0,0)","(1,","(1,2,3)","(10,9,9)","(2,","(8,","(8,2,3)","(a","(and","(apttypedds)","(apttypedds2)","(case","(chris,map(0","(class:","(column:","(e.g.","(e.g.,","(empti","(enjoy","(frameless.typedcolumn[(string,","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(from","(i","(i#1771l","(if","(implicit","(in","(includ","(int,","(isnotnull(i#1771l)","(john,map(0","(look","(lyon,166500.0))","(name","(name:","(or","(paris,333333.3333333333),","(peopl","(phonebooktf:","(repres","(sam,map(0","(sample:","(see","(semigroup)","(seq[(int,","(string,","(such","(the","(thumb","(u:","(up","(what","(which","(with","(wrappedarray((1,string)),2)",")","))",").as[apartmentdetails]",").as[aptpricecity].show().run",").as[stats].show().run()",").show().run()",").show(1).run()",").show(2).run()","*","*deserializetoobject","*filescan","*filter","*mapel","*project","*serializefromobject","+","++=","+1,",",","...","...).",".ac",".appli",".as[family]()",".as[housedatawithfeatures]",".as[neighborhoodcount]()",".dataset",".desc.",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select($\"*\",",".select('_2,",".select('neighborhood)",".sortdesc('count)","/","//","0)))","0.0|","0.0|325000.0|","0.13.13:","0.2,","0.4.0","0.4.1","0.5.0","1","1)","1))","1)),","1),","1,","1.0","1.0.0","1.0.1","1.1|","1.6","1.6+,","1.6,","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10).select(fds('i)).explain()","10).select(fds('i)).show().run()","10).select(fds('x))","10,","100)","100,","10000.0,","100000)))","100000),","102|","10|","11","11))","12)","12,","133000.0,","133000.0|","15)))","15:18:58","18","1:","1|","1|250000.0|","2","2)","2)#1890l]","2))","2)),","2),","2).as[updatedsurface]","2).show().run()","2,","2.0","2.0)","2.0,","2.10,","2.11","2.11,","2.11.x.","2.2.0","2.2.1","2.3.2.","20%","20)","20,","200000),","200000.0,","200000.0|","2018))","22.","2229621),","2229621|","2409.6385542168673,","25,","250000),","250000.0,","250000.0|","250|","25|[paris,","27|","2955.5555555555557,","2:","2|","2|300000.0|","2|[a,","3","3)","3))","3),","3,","300000.0,","300000.0|","32,","325000.0,","325000.0|","343629)","343629|","3|","3|450000.0|","3|[a,","4","4))","4)),","4,","430","4391.891891891892)","4391.891891891892|","45,","4500.0,","450000.0,","450000.0|","450|","454","45|133000.0|","47|","5,","50,","500000)","500000),","500715),","500715|","500|","52|","6,","6833.333333333333|","74,","740|","76|","770","800000)))","83,","830|","83|200000.0|","854","85|","900000)",":",":)",":20:",":23:",":24:",":25:",":26:",":27:",":28:",":29:",":30:",":31:",":35:",":36:",":37:",":39:",":44",":46",":47",":50","::",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","==","===","=>",">",">=","???","['citi]","['x]","[1...10]).","[1.0,2.0,3.0]","[],","[_1:","[a]frameless.typedcolumn[foo,a]","[age:","[city#53,","[city,","[city:","[features:","[i#1771l","[i#1771l,j#1772]","[i#1771l]","[i,","[i:","[input[0,","[isnotnull(i),","[lyon,500715]|","[nice,343629]|","[out,","[out]frameless.typedaggregate[foo,out]","[ratio:","[squarefeet:","[sum(i#1771l)","^","_1#1876l]","_1|","_2:","_2|","_3|","_4|","`sum(i)`)'","a)(implicit","a):","ab","abil","abov","above)","above,","above.","abstract","accept","access","accident","achiev","act","action","action[(seq[(int,","action[t]","actual","ad","add","addit","address","address,","address:","adelbertc","adjustedpric","adjustedprice.show().run()","adjustedprice:","aforement","again","against","agg()","agg(avg(aptds('price))).","aggreg","aggregated,","agree.","algebra","alia","alias","align","align.","allcities:","allcities|","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","allowed,","allowed:","along","alphabet:","alternatively,","alternatives:","amount","and/or","anna","annotate/nam","annoy","anoth","another,","anyth","apach","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartment.","apartmentdetail","apartmentdetails(city:","apartmentdetails?","apartmentshortinfo","apartmentshortinfo(city:","apartmentshortinfo?","api","api,","api.","apis),","apis.","appear","append","appli","applic","applications.","apply(a:","apply(d:","approach","approxim","aptd","aptds('city),","aptds('price)","aptds('price)))","aptds('price),","aptds('surface),","aptds('surface).cast[double]","aptds('surface).cast[double])","aptds.","aptds.agg(","aptds.select(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)","apttypedds('city)).as[updatedsurface]","apttypedds('city).asc,","apttypedds('city).cast[double]","apttypedds('price).desc","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.joininner(citiinfotypedds)","apttypedds.makeudf(pricemodifier)","apttypedds.orderby(","apttypedds.orderby(apttypedds('city).asc).show(2).run()","apttypedds.project[apartmentshortinfo]","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds.union(apttypedds2).show().run","apttypedds2","apttypedds2('price)","apttypedds2('price)).","apttypedds2.drop[citybeds]","apttypedds2.droptupled('price):","apttypedds2.union(apttypedds).show().run","apttypedds2.withcolumnreplaced('price,","apttypedds2.withcolumntupled(","apttypedds2.withcolumntupled(lit(array(\"a\",\"b\",\"c\"))).show(2).run()","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","are:","area","argument","arguments)","arithmet","ariti","arity.","around","array","array((joe,map(0","array(1,","array[(username,","array]","arraycontains(t('_1),","arraycontains(t('_2),","arraycontains:","as:","as[bedroomstats]","as[long]","as[t]","ascol()","ascol(),","assembl","assembler.transform(testdata).as[housedatawithfeatures]","assembler.transform(trainingdata)","assembler.transform(trainingdata).as[housedatawithfeatures]","assembler.transform(trainingdata).as[wronghousefeatures]","assembler.transform(wrongtrainingdata)","assembler:","associ","assum","avail","available,","available.","averag","averaging,","avg","avg(aptds('price))","avg(aptds('price)),","avg(aptds('surface))","avg(aptds('surface)),","avg,","avgprice:","avgpricebeds1:","avgpricebeds2:","avgpricebeds3:","avgpricebeds4:","avgprice|","avgsurface:","avgsurface|minsurface|","avoid","away:","b","b):","b,","b.","b:","b]","back","bar","bar(1)))","bar(1.1,","bar(d:","bar(i:","bar)","bardate(1.1,","bardate(d:","bardate)","base","batched:","be","bedroom","bedrooms#56]","bedrooms.","bedrooms:","bedrooms];;","bedroomstat","bedroomstats(","bedroomstats('avgpricebeds2).getorelse(0.0),","bedroomstats('avgpricebeds3).getorelse(0.0))","bedroomstats(lyon,some(133000.0),some(200000.0),none,none)","bedroomstats(nice,none,none,some(325000.0),none)","bedroomstats(paris,some(250000.0),some(300000.0),some(450000.0),none)","bedroomstats.collect().run().foreach(println)","bedroomstats.select(","bedroomstats.show().run()","bedroomstats:","before.","behav","below","benefit","besid","bestneighborhood","better","between","bigint","bigint))","bigint,","bigint]","bind","birthday:","block","boolean","boolean)","boolean):","boolean)]","boolean)].","boolean,","boolean:","bootstrap","both","break","bring","bug","build.sbt","built","bulletproof:","c","c('_2)).show(2).run()","c,","c.","c.select(c.colmany('_1,","c.show(1).run()","c:","c]|","calcul","call","caller","calls,","can't","can't,","capabl","captur","care","case","case)","case.","cast","cast(10","cast(2","cast,","cat","catalyst","catalystcast.","catalystcast[string,","catch","categor","cats\"","cats,","cats.","cats.data.readert","cats.effect.implicits._","cats.effect.io","cats.effect.sync","cats.effect.sync[f].","cats.implicit","cats.implicits._","cats.mtl.implicits._","cats:","caught","caus","chang","channel","check","choos","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name)","city.","city:","cityb","citybeds(city:","citybeds(lyon,2))","citybeds(paris,1))","citybeds(paris,1),","citybeds(paris,3))","citybeds(paris,3),","citybeds.","citybeds.head(3).run()","citybeds.headoption.run()","citybeds.limit(4).collect().run()","citybeds.select(citybeds.ascol,","citybeds.take(2).run()","citybeds:","citybedsoth","citybedsother(city:","cityindexed:","cityinfo","cityinfo(city:","citymapentry(","citymaptf:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.select(cityratio('city),","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|avgpricebeds1|avgpricebeds2|avgpricebeds3|avgpricebeds4|","city|bedrooms|","city|surface|","class","class:","classes)","classes.","clause.","clearli","click","close","closur","closures.","cmax","cmin","code","code.","collect","collect())","collection,","collectset(aptds('city))","colmany()","column","column(s)","column(s).","column,","column.","column:","columnar","columns)","columns,","columns.","columns:","combin","come","common","commonli","companion","compar","comparison","comparison,","compat","compil","compile)","compile,","compile.","compile:","compiles:","complet","complex","compos","composit","comprehens","compromis","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","concat,","concept:","condition","conduct","conf","confus","consid","consist","consol","construct","constructor","contain","content","context","continu","contrari","contribut","contributor","conveni","convert","correct","correct.","correctli","correspond","count","count,","count:","countandtakejob","counterpart","coupl","creat","csum,","current","custom","customizable,","d.gettime()","d:","d]|true|","data","data)","data,","data.","data:","datafram","dataframe,","dataframes,","dataset","dataset\"","dataset,","dataset.","dataset/datafram","dataset:","dataset?.","dataset[daterange]","dataset[long].","datasets,","datawithfeatur","datawithfeatures:","daterange(s:","datetolonginject","datetolonginjection:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","deal","decod","def","default","defin","definit","delay","depend","deprec","deriv","derived,","descript","description.","description:","design","detail","detail.","detect","develop","differ","different,","direct","directli","discuss","discussion.","disk","distinguish","dive","divid","document","document.","domain","don't","done","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","drop","drop().","drop/replace/add","droptupled()","ds","ds.collect()","ds.filter($\"i\"","ds.filter(_.i","ds.select(sum($\"i\"),","ds.show()","ds:","due","e.g.,","e:","each","earli","easi","easier","easili","effect","effect:","effects.","element","elements.","elements:","elid","empti","empty,","emptyrdd","emptyrdd[15]","encod","encoder,","encoder.","encoder:","encoders,","enhanc","enough","enrich","ensur","entir","environ","equalto(i,10)],","equival","error","error)","error.","error:","essenti","estimator.","estimators.","etc)","etc.","everyth","evid","evidence$1:","exactli","exampl","example,","example.","example:","except","exclus","execut","exist","expect","expected:","expens","explain","explan","explicit","explicitli","expos","express","expression'","extend","extra","extrem","e|","f","f.neighborhood))","f.residents.split('","f[_]","f[_],","f[a]","f[a],","fact","fail","failure:","false,","false]","familiar","family(residents:","family:","fanci","fd","fds('i)).show().run()","fds.agg(fsum(fds('i))+22).show().run()","fds.agg(fsum(fds('i)),","fds.filter(fds('i)","fds.select(fsum(fds('i)))","fds:","featur","features(price:","features(squarefeet:","features).","features):","features.","features:","feb","feed","feel","femal","few","field","field]","fields.","fields]","file","file.","filter","filter(conditionexpr:","filteredd","filteredds.explain()","filteredds.show()","filteredds:","finaljob","finaljob.","finaljob:","finally,","find","first","first()","first,","first_value)","fit","five","flat","focu","follow","follows:","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo(s:","foo,","foo.","foodate(i:","footag","footage.","forest,","form","formal","format","format:","found","found:","frameless","frameless'","frameless,","frameless.","frameless._","frameless.abstracttypedcolumn[?t,?c[?a]]","frameless.abstracttypedcolumn[t,c[a]]","frameless.abstracttypedcolumn[t,c[a]],","frameless.catalystcast[string,double]","frameless.catalystcollection[c])column.thistype[t,boolean]","frameless.catalystdivisible[double,out],","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.cats.implicits.","frameless.cats.implicits._","frameless.cats.implicits._.","frameless.cats.outer._","frameless.functions._","frameless.functions.aggregate._","frameless.functions.aggregate.{sum","frameless.functions.aggregate.{sum=>fsum}","frameless.functions.lit","frameless.functions.nonaggregate._","frameless.functions.nonaggregate.when","frameless.injection$$anon$1@4d1cf7ad","frameless.injection$$anon$1@6cd20faa","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.job","frameless.job$$anon$2@30c69a34","frameless.job$$anon$4@558c6c17","frameless.job[int]","frameless.job[seq[foo]]","frameless.job[seq[int]])frameless.job[int]","frameless.ml._","frameless.ml.appendtransformer[rfinputs,frameless.ml.classification.typedrandomforestclassifier.outputs,org.apache.spark.ml.classification.randomforestclassificationmodel]","frameless.ml.appendtransformer[rfinputs,frameless.ml.regression.typedrandomforestregressor.outputs,org.apache.spark.ml.regression.randomforestregressionmodel]","frameless.ml.appendtransformer[stringindexerinput,frameless.ml.feature.typedstringindexer.outputs,org.apache.spark.ml.feature.stringindexermodel]","frameless.ml.classification._","frameless.ml.classification.typedrandomforestclassifier@be7ee","frameless.ml.classification.typedrandomforestclassifier[rfinputs]","frameless.ml.feature._","frameless.ml.feature.typedindextostring@c97d749","frameless.ml.feature.typedindextostring[indextostringinput]","frameless.ml.feature.typedstringindexer@666bcbec","frameless.ml.feature.typedstringindexer[stringindexerinput]","frameless.ml.feature.typedvectorassembler@159b3f1","frameless.ml.feature.typedvectorassembler@66b12f1","frameless.ml.feature.typedvectorassembler[features]","frameless.ml.regression._","frameless.ml.regression.typedrandomforestregressor@4c620c93","frameless.ml.regression.typedrandomforestregressor[rfinputs]","frameless.ml.typedestimator$$anonfun$fit$1$$anon$1@20355c2f","frameless.ml.typedestimator$$anonfun$fit$1$$anon$1@36ed2d44","frameless.ml.typedestimator$$anonfun$fit$1$$anon$1@5a0797","frameless.ops.as[(double,","frameless.ops.as[(string,","frameless.syntax._","frameless.typedaggregate[foo,?]","frameless.typedcolumn[(string,","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[foo,?]","frameless.typedcolumn[tt,double])(implicit","frameless.typeddatafram","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(citybeds,","frameless.typeddataset[(double,","frameless.typeddataset[(int,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[apartmentshortinfo]","frameless.typeddataset[bedroomstats]","frameless.typeddataset[citybeds]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[foo]","frameless.typeddataset[housecityprediction]","frameless.typeddataset[housecitypredictionindexed]","frameless.typeddataset[housecitypredictioninputs]","frameless.typeddataset[housedata]","frameless.typeddataset[housedatawithfeatures]","frameless.typeddataset[housedatawithfeaturesandindex]","frameless.typeddataset[housepriceprediction]","frameless.typeddataset[int]","frameless.typeddataset[person]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","frameless.typeddataset[wronghousedata]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless.typedencoder[mydate]","frameless.typedencoder[out],","frameless.typedencoder[person]","frameless.with[apartment,tt]{typ","frameless:","framelessvers","framelessversion,","francisco\",","francisco)","free","friend.","friendli","from)","fsum}","full","fulli","function","function(s)","function.","function:","functions.","functions:","further","futur","g8","garden","gender","gender)","gender:","gendertoint:","gener","general).","generated.","get","get.;;","getorelse().","giter8","github,","gitter","gitter)","give","given","go","goal","goal:","goe","great!","ground,","group","groupbi","groupby()","groupby(aptds('city)).","guard","handhold","handl","hasgarden","hasgarden:","have","help","help?","here","here.","hierarchi","hold","hood,","hous","housecitypredict","housecityprediction(","housecitypredictionindex","housecitypredictionindexed(","housecitypredictioninput","housecitypredictioninputs(features:","housedata","housedata(100,","housedata(150,","housedata(20,","housedata(200,","housedata(50,","housedata(squarefeet:","housedata?","housedatawithfeatur","housedatawithfeatures(squarefeet:","housedatawithfeaturesandindex","housedatawithfeaturesandindex(","housepricepredict","housepriceprediction(","however,","http://opensource.org/licenses/apach","i.","i:","id","ident","if(nam","ignor","imario","imarios/frameless.g8","implement","implicit","implicitli","implicits.scala:42","implicits.scala:67","import","improv","inabl","includ","incompat","index","indexeddata","indexeddata:","indexedpredict","indexedpredictions:","indexedtestdata","indexedtestdata.project[housecitypredictioninputs]","indexedtestdata:","indexer.fit(datawithfeatures).run()","indexer:","indexermodel","indexermodel.transform(datawithfeatures).as[housedatawithfeaturesandindex]","indexermodel.transform(testdatawithfeatures).as[housedatawithfeaturesandindex]","indexermodel:","indextostr","indextostring.transform(indexedpredictions).as[housecityprediction]","indextostring:","indextostringinput","indextostringinput(predictedcityindexed:","inflat","inflation.show(2).run()","inflation:","inform","initi","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","inmemoryfileindex[file:/tmp/foo],","input","insid","instal","instanc","instance.","instances:","instanti","instead","instead.","int","int)","int).","int)]","int,","int.","int]","integr","intention","interest","intermedi","intern","introduc","introduct","intuitively,","invalid","invert(b:","invert(l:","io","issues.","issues/questions.","it'","it.","i|","j.","j:","j];;","jar.","java.lang.unsupportedoperationexception:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date(system.currenttimemillis))))","java.util.date)","java.util.date))","java.util.date)))","java.util.date))))","java.util.date).gettime(),","java.util.date):","java.util.date,","java.util.date.","jeremyrsmith","job","job,","job[a]","job[int]","job[seq[int]]):","jobs.","joe","join","join1(tf1:","join2(tf1:","joins,","jvm","j|","kanterov","keep","kernel","key","key.","keys.","know","label","label)","label):","label,","languag","larg","last","layer","lazi","lazili","lazy,","lazy.","lead","learning.","less","let","let'","letter","level","leverag","librari","library:","librarydepend","licens","lift","like,","limit","limitations.","line","linux","list","list(","list(person(42,male))","list(person(42,sun","list[string])","list[string]),string]","list[string]),string],","list[string])]","lit(0.001))","lit(1.1)).","lit(list(\"a\",\"b\",\"c\")))","lit(list(\"abc\",\"c\",\"d\")))","litaggr(\"hello","liter","load","local","localrel","locat","location:","long","long)","long)))","long):","long)]","long)])","long,","long:","long]","look","loos","lowest","lyon]|","lyon|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","mac","machineri","macro","made","main","maintain","make","makerdd","male","male))","manag","mani","manipul","manner.","map","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[25]","mapvalu","match","materialize.","math","matrices.dense(2,","matrix","matrix))","matrix:","matrix]","matrixd","matrixds:","matter","max,","meaning","mechan","member","members.","mention","merg","messag","method","method,","method.","mf","min\").","min(aptds('surface)),","min(aptds('surface)).cast[double],","min,","minim","minimum","minsurface:","mirror","mismatch;","miss","missing,","misspel","mistak","mix","ml","ml\"","ml'","model","model.","model.transform(testdata)","model.transform(testdatawithfeatures)","model.transform(testdatawithfeatures).as[housepriceprediction]","model.transform(testinput).as[housecitypredictionindexed]","model:","moder","modifi","modul","module,","modules:","monad","more","moreover,","mtl","much","mydat","mydate(jday:","n","n:","name","name.exists(set('x',","name:","namely,","names,","names/typ","names/types,","natur","need","needed:","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","neighborhoods:","nest","new","newinstance(class","next","next,","nice,","nice|","nice|325000.0|","nil","nil)","nlplib","nlplib.uniquename(p.name)","non","none","none).","normal","not,","not.","note","noth","notifi","now","now,","null|","number","number,","numer","obj#1803:","obj#1804:","object","object.","obtain","obviou","of)","offer","offici","often,","ok","olivierblanvillain","on","on(1,2,3,4).","onc","ontypeddataframe.","onward.","open","oper","operation.","operations,","operations:","optim","optimizer)","option","option.","option[citybeds]","option[double])","option[double],","order","order.","org.apache.spark.ml.linalg._","org.apache.spark.ml.linalg.matrix","org.apache.spark.ml.linalg.matrix)]","org.apache.spark.ml.linalg.matrix:","org.apache.spark.ml.linalg.matrixudt.","org.apache.spark.ml.linalg.vector","org.apache.spark.ml.linalg.vector),wronghousefeatures]","org.apache.spark.ml.linalg.vector)]","org.apache.spark.ml.linalg.vectorudt","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","org.apache.spark.sql,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.analyzer.failanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:88)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$9.apply(checkanalysis.scala:280)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$checkanalysis$class$$anonfun$$checkvalidaggregateexpression$1$5.apply(checkanalysis.scala:253)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:280)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.org$apache$spark$sql$catalyst$analysis$checkanalysis$class$$anonfun$$checkvalidaggregateexpression$1(checkanalysis.scala:239)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.org$apache$spark$sql$catalyst$analysis$checkanalysis$class$$anonfun$$checkvalidaggregateexpression$1(checkanalysis.scala:253)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.failanalysis(checkanalysis.scala:39)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:71)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$6.apply(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1$1.apply(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$transformexpressionsup$1.apply(queryplan.scala:268)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:289)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:268)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1$$anonfun$10.apply(scalareflection.scala:614)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1$$anonfun$10.apply(scalareflection.scala:626)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1.apply(scalareflection.scala:455)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1.apply(scalareflection.scala:614)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1.apply(scalareflection.scala:632)","org.apache.spark.sql.catalyst.scalareflection$.cleanupreflectionobjects(scalareflection.scala:39)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:455)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:444)","org.apache.spark.sql.catalyst.scalareflection$class.cleanupreflectionobjects(scalareflection.scala:809)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:70)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:289)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:127)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:187)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:288)","org.apache.spark.sql.datafram","org.apache.spark.sql.dataset","org.apache.spark.sql.dataset$.ofrows(dataset.scala:67)","org.apache.spark.sql.dataset.(dataset.scala:165)","org.apache.spark.sql.dataset.(dataset.scala:171)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2884)","org.apache.spark.sql.dataset.select(dataset.scala:1150)","org.apache.spark.sql.dataset.select(dataset.scala:1210)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:275)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:52)","org.apache.spark.sql.functions.sum","org.apache.spark.sql.lowprioritysqlimplicits$class.newproductencoder(sqlimplicits.scala:233)","org.apache.spark.sql.sparksess","org.apache.spark.sql.sqlcontext","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:33)","org.apache.spark.sql.types.userdefinedtype[a]","org.apache.spark.{sparkconf,","origin","os","other:","otherwise(lit(0.0))).show(8).run()","other|","out","outer","over","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","overflow","overhead","overload","overview","overview):","p","packag","pair","parallelcollectionrdd[14]","parallelcollectionrdd[16]","parallelcollectionrdd[18]","parallelcollectionrdd[20]","parallelcollectionrdd[21]","paramet","parquet","parquet,","part","partial","particular","partitionfilters:","pass","peopl","people:","per","perform","performance.","perhap","person","person(age:","person(name:","person(r,","persond","personds:","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","physic","pivot","pivot(aptds('bedrooms)).","pivot,","place","plain","plan","plan,","plan.","plan:","pleas","point,","polymorph","popul","popular","population:","possibl","potenti","practic","pre","precis","predicates.","predict","predict).","predictedcity:","predictedcityindexed.","predictedcityindexed:","predictedprice:","predictions.select(predictions.col('predictedcity)).collect.run()","predictions.select(predictions.col('predictedprice)).collect.run()","predictions:","prefer","preserv","previou","previous","price","price#55,","price,","price/surfac","price:","price:double)","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","price|bedrooms|","primit","println(data.cmax)","println(data.cmaxoption)","println(data.cmin)","println(data.cminoption)","println(data.csum)","println(data.csumoption)","probability:","probabl","problem","problem.","problemat","process","product","product,","product.","program","program,","programm","project","project,","project:","projectio","projections/selections.","proof","properli","prove","provid","pst","public","pull","pushedfilters:","queri","question","quick","q|","r","rais","random","ratio","ratio:","ratio|","rawprediction:","rdd","rdd.","rdd:","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","rdds,","read","readability.","readabl","readert","readert[io,","readi","readschema).","readschema:","reasons,","recurs","reducebykey","refer","referenc","reflect","relation[i#1771l,j#1772]","releases.","remind","repl\").set(\"spark.ui.enabled\",","replac","repres","represent","request","requests)","requests.","requir","required:","res16:","res17:","res19:","res20:","res27:","res28:","res29:","res2:","res30:","res35:","res5:","res6:","res8:","residents:","resolut","resolv","result","result.","result.run(spark).unsaferunsync()","result:","resultwithdescription.run(spark).unsaferunsync()","resultwithdescription:","rethought","retriev","return","reus","rf","rf.fit(indexeddata).run()","rf.fit(trainingdatawithfeatures)","rf.fit(trainingdatawithfeatures).run()","rf.fit(wrongtrainingdatawithfeatures)","rf:","rfinput","rfinputs(cityindexed:","rfinputs(price:","rfinputs.","right","right?","root","row","run","run()","run:","runtim","runtime.","s:","sadly,","safe","safe,","safe.","safeti","safety!","safety,","safety.","sale","same","sampl","sample.map(_.min)","samplestat","samplestats.show().run()","samplestats:","save","say,","sbt","sc.emptyrdd","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala","scala.","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.immutable.sortedmap","scala.collection.immutable.sortedmap[string,int])]","scala.collection.map[string,scala.collection.immutable.sortedmap[string,int]]","scala.collection.map[user,transactioncount]","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala.reflect.internal.tpe.typeconstraints$undolog.undo(typeconstraints.scala:56)","scala>","scalareflect","schema","schema.","seal","second","second,","secondari","section","see","see,","seem","select","select()","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","selectmany()","selectmany,","semigroup","sense,","separately,","seq(","seq(person(42,","seq[(string,","seq[citybeds]","seq[double]","seq[person]","seq[string]","sequenc","serial","serializ","serv","set","sever","shadow","shapeless","shapeless'","shapeless.hlist","shapeless.tag.tagged[string(\"citi\")]","shapeless.tag.tagged[string(\"x\")]","shell","shorter","show","show()","show(1).run()","showcas","shown","shuffledrdd[17]","shuffledrdd[19]","sign","signatur","signatures:","similar","similar)","similarly,","simpl","simpli","simplifi","simplist","simply:","singl","situat","size","skip","slow","small","snippet,","solut","solv","some(citybeds(paris,2))","sort","sortedmap(\"task1\"","sortedmap(\"task3\"","sorting.","sourc","spark","spark'","spark).","spark,","spark.","spark.createdataset(","spark.createdataset(apartments)","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark.sparkcontext.setloglevel(\"warn\")","spark:","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparkdelay","sparkdelay[f[_]]","sparkdelay[f].","sparksess","sparksession,","sparksession.","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","sqlcontext","sqlcontext):","sqlcontext.createdataset(seq(daterange(new","squar","squarefeet:","stack","stack.","stack:","stage","standard","start","stat","statement","statement).","stats(","stay","still","store","strict","string","string(\"abc\")","string)","string),updatedsurface]","string):","string)]","string)])","string)],","string,","string.","string]","stringindexerinput","stringindexerinput(city:","strongli","struct","struct,","struct]","structur","subsequ","subset","such","suffici","suggests,","sum","sum(i)#1889l,","sum,","summari","suppli","support","suppos","surfac","surface#54,","surface,","surface:","suspend","suspended.","suspens","symbol","syntax","syntax.","syntax:","syntaxes.","system","systems,","t","t.withcolumntupled(","t:","t]","tabl","table,","tables:","take","target","task","task2","task3","tdataframe[schema","tdataframe[schema]","techniqu","tell","ten","term","test","test.","testdata","testdata.","testdata:","testdatawithfeatur","testdatawithfeatures:","testinput","testinput:","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","thank","then,","therefore,","thing","this.","those","thread","three","through","thunk","time","time,","time.","time:","timeseri","timeseries)]","togeth","together.","top","totalperus","totalperuser.collectasmap","totalperuser:","toy","trace):","trace,","track","track,","train","trainingdata","trainingdata:","trainingdatawithfeatur","trainingdatawithfeatures:","trait","transactioncount","transactioncount)]","transform","transformations.","tri","troubl","true,","tt,","tupl","tuple23","tutori","two","two.","type","type,","type.","type:","type;","typeclass","typeclass,","typeclass:","typedaggreg","typedcolumn","typedd","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry])","typeddataframe[citymapentry].","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","typeddataset","typeddataset'","typeddataset,","typeddataset.","typeddataset.create(1","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset.create(ds)","typeddataset.create(people)","typeddataset.create(seq(","typeddataset.create(seq(\"label\"","typeddataset.create(seq((1,","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset.create(seq(housedata(120,","typeddataset.create(seq(housedata(20,","typeddataset.create(seq(housedata(70,","typeddataset.create(seq(mydate(new","typeddataset.create(seq(wronghousedata(20,","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[(string,int)]","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[apartmentshortinfo]","typeddataset[citybeds]","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","typeddatasets.","typedds:","typedencod","typedencoder[a]","typedestim","typedestimator,","typedestimators,","typedindextostr","typedindextostring[indextostringinput](indexermodel.transformer.labels)","typedrandomforestclassifi","typedrandomforestclassifier.","typedrandomforestclassifier[rfinputs]","typedrandomforestregressor","typedrandomforestregressor.","typedrandomforestregressor[rfinputs]","typedrandomforestregressor[wrongrfinputs]","typedstringindex","typedstringindexer[stringindexerinput]","typedtransform","typedtransformercan","typedvectorassembl","typedvectorassembler[features]","typedvectorassembler[wrongfeatures]","typeencod","typelevel","types)","types,","types.","types:","typesaf","typesafeti","typo","typo,","u","udf","udf(aptds('city),","udf:","ui","unabl","under","underli","unfortunately,","union","uniqu","uniquename(name:","unit:","unlik","unsaf","up","up,","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","user'","usernam","usual","util","val","valid","valu","value#1805l]","value,","value.","value:","vanilla","variabl","variou","vector","vector)","vector))","vector,","vector:","vector[string])","vector]","vectorassembl","vectorassembler)","vectorassembler.transform(testdata).as[housedatawithfeatures]","vectorassembler.transform(trainingdata).as[housedatawithfeatures]","vectorassembler:","vectord","vectords:","vectors.dense(1,","vectors:","verbos","veri","version","versions.","via","view","vs","w:","w](other:","want","way","way,","well","well,","well.","when(apttypedds2('city)","when/otherwis","whenev","wherea","why?","window","with,","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withcolumn()","withcolumn(),","withcolumn[citybedsother](lit(list(\"a\",\"b\",\"c\"))).","withcolumntupled()","withdescription(\"sampl","withgroupid(\"samplingjob\").","without","won't","work","work,","worked,","world\")","world|","wrap","wrappedarray((nice,325000.0),","wrappedarray(420000.0)","wrappedarray(6000.0,","wrappedarray(citybeds(paris,2),","wrappedarray(san","wrong","wrongfeatur","wrongfeatures(squarefeet:","wronghousedata","wronghousedata(squarefeet:","wronghousedata?","wronghousefeatures(","wrongrfinput","wrongrfinputs(labelofwrongtype:","wrongtrainingdata","wrongtrainingdata:","wrongtrainingdatawithfeatur","wrongtrainingdatawithfeatures:","w|","w})frameless.typedcolumn[w,out]","x","x:","yet.","zero.","{","|","|+|","|1000|102|","|100|","|133|","|200000.0|","|276333.3333333333|62.833333333333336|","|300000.0|450000.0|","|4500.0|450000.0|","|6000.0|300000.0|","|6908333.333333333|12.566666666666668|hello","|[lyon,45,133000.0,1]|","|[lyon,83,200000.0,2]|","|[nice,74,325000.0,3]|","|[paris,100,450000...|[paris,2229621]|","|[paris,25,250000....|[paris,2229621]|","|[paris,2]|[a,","|[paris,50,300000....|[paris,2229621]|","|city|surface|","|lyon|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|paris|[a,","|paris|[abc,","|value|","}","})","},"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"Introduction","keywords":"","body":"Frameless\n\n\n\n\nFrameless is a Scala library for working with Spark using more expressive types. \nIt consists of the following modules:\n\nframeless-dataset for a more strongly typed Dataset/DataFrame API   \nframeless-ml for a more strongly typed Spark ML API based on frameless-dataset\nframeless-cats for using Spark's RDD API with cats\n\nNote that while Frameless is still getting off the ground, it is very possible that breaking changes will be\nmade for at least the next few versions.\nThe Frameless project and contributors support the\nTypelevel Code of Conduct and want all its\nassociated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning.\nVersions and dependencies\nThe compatible versions of Spark and \ncats are as follows:   \n\n\n\nFrameless\nSpark\nCats\n\n\n\n\n0.4.0\n2.2.0\n1.0.0-MF\n\n\n0.4.1\n2.2.0\n1.0.1\n\n\n0.5.0\n2.2.1\n1.0.1\n\n\n\nThe only dependency of the frameless-dataset module is on shapeless 2.3.2. \nTherefore, depending on frameless-dataset, has a minimal overhead on your Spark's application jar. \nOnly the frameless-cats module depends on cats, so if you prefer to work just with Datasets and not with RDDs, \nyou may choose not to depend on frameless-cats. \nFrameless intentionally does not have a compile dependency on Spark. \nThis essentially allows you to use any version of Frameless with any version of Spark. \nThe aforementioned table simply provides the versions of Spark we officially compile \nand test Frameless with, but other versions may probably work as well. \nWhy?\nFrameless introduces a new Spark API, called TypedDataset. \nThe benefits of using TypedDataset compared to the standard Spark Dataset API are as follows:\n\nTypesafe columns referencing (e.g., no more runtime errors when accessing non-existing columns)\nCustomizable, typesafe encoders (e.g., if a type does not have an encoder, it should not compile) \nEnhanced type signature for built-in functions (e.g., if you apply an arithmetic operation on a non-numeric column, you \nget a compilation error)\nTypesafe casting and projectios\n\nClick here for a \ndetailed comparison of TypedDataset with Spark's Dataset API. \nDocumentation\n\nTypedDataset: Feature Overview\nTyped Spark ML\nComparing TypedDatasets with Spark's Datasets\nTyped Encoders in Frameless\nInjection: Creating Custom Encoders\nJob[A]\nUsing Cats with RDDs\nProof of Concept: TypedDataFrame\n\nQuick Start\nFrameless is compiled against Scala 2.11.x.\nTo use Frameless in your project add the following in your build.sbt file as needed:\nval framelessVersion = \"0.5.0\"\n\nlibraryDependencies ++= List(\n  \"org.typelevel\" %% \"frameless-dataset\" % framelessVersion,\n  \"org.typelevel\" %% \"frameless-ml\"      % framelessVersion,\n  \"org.typelevel\" %% \"frameless-cats\"    % framelessVersion  \n)\n\nAn easy way to bootstrap a Frameless sbt project:\n\nif you have Giter8 installed then simply:\n\ng8 imarios/frameless.g8\n\n\nwith sbt >= 0.13.13:\n\nsbt new imarios/frameless.g8\n\nTyping sbt console inside your project will bring up a shell with Frameless\nand all its dependencies loaded (including Spark).\nNeed help?\nFeel free to messages us on our gitter \nchannel for any issues/questions.\nDevelopment\nWe require at least one sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers\n(people who can merge pull requests) are:\n\nadelbertc\nimarios\njeremyrsmith\nkanterov\nnon\nOlivierBlanvillain\n\nLicense\nCode is provided under the Apache 2.0 license available at http://opensource.org/licenses/Apache-2.0,\nas well as in the LICENSE file. This is the same license used as Spark.\n"},"FeatureOverview.html":{"url":"FeatureOverview.html","title":"TypedDataset: Feature Overview","keywords":"","body":"TypedDataset: Feature Overview\nThis tutorial introduces TypedDataset using a simple example.\nThe following imports are needed to make all code examples compile.\nimport org.apache.spark.{SparkConf, SparkContext}\nimport org.apache.spark.sql.SparkSession\nimport frameless.functions.aggregate._\nimport frameless.TypedDataset\n\nval conf = new SparkConf().setMaster(\"local[*]\").setAppName(\"Frameless repl\").set(\"spark.ui.enabled\", \"false\")\nimplicit val spark = SparkSession.builder().config(conf).appName(\"REPL\").getOrCreate()\nspark.sparkContext.setLogLevel(\"WARN\")\n\nimport spark.implicits._\n\nCreating TypedDataset instances\nWe start by defining a case class:\ncase class Apartment(city: String, surface: Int, price: Double, bedrooms: Int)\n\nAnd few Apartment instances:\nval apartments = Seq(\n  Apartment(\"Paris\", 50,  300000.0, 2),\n  Apartment(\"Paris\", 100, 450000.0, 3),\n  Apartment(\"Paris\", 25,  250000.0, 1),\n  Apartment(\"Lyon\",  83,  200000.0, 2),\n  Apartment(\"Lyon\",  45,  133000.0, 1),\n  Apartment(\"Nice\",  74,  325000.0, 3)\n)\n\nWe are now ready to instantiate a TypedDataset[Apartment]:\nval aptTypedDs = TypedDataset.create(apartments)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nWe can also create one from an existing Spark Dataset:\nval aptDs = spark.createDataset(apartments)\n// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval aptTypedDs = TypedDataset.create(aptDs)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nOr use the Frameless syntax:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval aptTypedDs2 = aptDs.typed\n// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nTypesafe column referencing\nThis is how we select a particular column from a TypedDataset:\nval cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))\n// cities: frameless.TypedDataset[String] = [_1: string]\n\nThis is completely type-safe, for instance suppose we misspell city as citi:\naptTypedDs.select(aptTypedDs('citi))\n// :27: error: No column Symbol with shapeless.tag.Tagged[String(\"citi\")] of type A in Apartment\n//        aptTypedDs.select(aptTypedDs('citi))\n//                                    ^\n\nThis gets raised at compile time, whereas with the standard Dataset API the error appears at runtime (enjoy the stack trace):\naptDs.select('citi)\n// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [city, surface, price, bedrooms];;\n// 'Project ['citi]\n// +- LocalRelation [city#53, surface#54, price#55, bedrooms#56]\n// \n//   at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:88)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:85)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:70)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:288)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:279)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:289)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1$1.apply(QueryPlan.scala:293)\n//   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n//   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n//   at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)\n//   at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)\n//   at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n//   at scala.collection.AbstractTraversable.map(Traversable.scala:104)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:293)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$6.apply(QueryPlan.scala:298)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:187)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:298)\n//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:268)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:85)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)\n//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)\n//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)\n//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:67)\n//   at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2884)\n//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1150)\n//   ... 430 elided\n\nselect() supports arbitrary column operations:\naptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()\n// +----+---+\n// |  _1| _2|\n// +----+---+\n// | 500| 52|\n// |1000|102|\n// | 250| 27|\n// | 830| 85|\n// | 450| 47|\n// | 740| 76|\n// +----+---+\n//\n\nNote that unlike the standard Spark API, where some operations are lazy and some are not, all TypedDatasets operations are lazy.\nIn the above example, show() is lazy. It requires to apply run() for the show job to materialize.\nA more detailed explanation of Job is given here.\nNext we compute the price by surface unit:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// :26: error: overloaded method value / with alternatives:\n//   (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] \n//   [Out, TT, W](other: frameless.TypedColumn[TT,Double])(implicit n: frameless.CatalystDivisible[Double,Out], implicit e: frameless.TypedEncoder[Out], implicit w: frameless.With[Apartment,TT]{type Out = W})frameless.TypedColumn[W,Out]\n//  cannot be applied to (frameless.TypedColumn[Apartment,Int])\n//        val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n//                                                                      ^\n\nAs the error suggests, we can't divide a TypedColumn of Double by Int.\nFor safety, in Frameless only math operations between same types is allowed:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect().run()\n// res6: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\nLooks like it worked, but that cast seems unsafe right? Actually it is safe.\nLet's try to cast a TypedColumn of String to Double:\naptTypedDs('city).cast[Double]\n// :27: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]\n//        aptTypedDs('city).cast[Double]\n//                              ^\n\nThe compile-time error tells us that to perform the cast, an evidence\n(in the form of CatalystCast[String, Double]) must be available.\nSince casting from String to Double is not allowed, this results\nin a compilation error.\nCheck here\nfor the set of available CatalystCast.\nCasting and projections\nWith select() the resulting TypedDataset is of type TypedDataset[TupleN[...]] (with N in [1...10]).\nFor example, if we select three columns with types String, Int, and Boolean the result will have type\nTypedDataset[(String, Int, Boolean)]. To select more than ten columns use the selectMany() method.\nSelect has better IDE support than the macro based selectMany, so prefer select() for the general case.\nWe often want to give more expressive types to the result of our computations.\nas[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long\nas the types in U and T align.\nWhen the cast is valid the expression compiles:\ncase class UpdatedSurface(city: String, surface: Int)\n// defined class UpdatedSurface\n\nval updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]\n// updated: frameless.TypedDataset[UpdatedSurface] = [city: string, surface: int]\n\nupdated.show(2).run()\n// +-----+-------+\n// | city|surface|\n// +-----+-------+\n// |Paris|     52|\n// |Paris|    102|\n// +-----+-------+\n// only showing top 2 rows\n//\n\nNext we try to cast a (String, String) to an UpdatedSurface (which has types String, Int).\nThe cast is not valid and the expression does not compile:\naptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// :29: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]\n//        aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n//                                                                  ^\n\nProjections\nWe often want to work with a subset of the fields in a dataset.\nProjections allows to easily select the fields we are interested\nwhile preserving their initial name and types for extra safety.\nHere is an example using the TypedDataset[Apartment] with an additional column:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\ncase class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)\n// defined class ApartmentDetails\n\nval aptWithRatio =\n  aptds.select(\n    aptds('city),\n    aptds('price),\n    aptds('surface),\n    aptds('price) / aptds('surface).cast[Double]\n  ).as[ApartmentDetails]\n// aptWithRatio: frameless.TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]\n\nSuppose we only want to work with city and ratio:\ncase class CityInfo(city: String, ratio: Double)\n// defined class CityInfo\n\nval cityRatio = aptWithRatio.project[CityInfo]\n// cityRatio: frameless.TypedDataset[CityInfo] = [city: string, ratio: double]\n\ncityRatio.show(2).run()\n// +-----+------+\n// | city| ratio|\n// +-----+------+\n// |Paris|6000.0|\n// |Paris|4500.0|\n// +-----+------+\n// only showing top 2 rows\n//\n\nSuppose we only want to work with price and ratio:\ncase class PriceInfo(ratio: Double, price: Double)\n// defined class PriceInfo\n\nval priceInfo = aptWithRatio.project[PriceInfo]\n// priceInfo: frameless.TypedDataset[PriceInfo] = [ratio: double, price: double]\n\npriceInfo.show(2).run()\n// +------+--------+\n// | ratio|   price|\n// +------+--------+\n// |6000.0|300000.0|\n// |4500.0|450000.0|\n// +------+--------+\n// only showing top 2 rows\n//\n\nWe see that the order of the fields does not matter as long as the\nnames and the corresponding types agree. However, if we make a mistake in\nany of the names and/or their types, then we get a compilation error.\nSay we make a typo in a field name:\ncase class PriceInfo2(ratio: Double, pricEE: Double)\n\naptWithRatio.project[PriceInfo2]\n// :29: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?\n//        aptWithRatio.project[PriceInfo2]\n//                            ^\n\nSay we make a mistake in the corresponding type:\ncase class PriceInfo3(ratio: Int, price: Double) // ratio should be Double\n\naptWithRatio.project[PriceInfo3]\n// :29: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?\n//        aptWithRatio.project[PriceInfo3]\n//                            ^\n\nUnion of TypedDatasets\nLets create a projection of our original dataset with a subset of the fields.\ncase class ApartmentShortInfo(city: String, price: Double, bedrooms: Int)\n\nval aptTypedDs2: TypedDataset[ApartmentShortInfo] = aptTypedDs.project[ApartmentShortInfo]\n\nThe union of aptTypedDs2 with aptTypedDs uses all the fields of the caller (aptTypedDs2)\nand expects the other dataset (aptTypedDs) to include all those fields. \nIf field names/types do not match you get a compilation error. \naptTypedDs2.union(aptTypedDs).show().run\n// +-----+--------+--------+\n// | city|   price|bedrooms|\n// +-----+--------+--------+\n// |Paris|300000.0|       2|\n// |Paris|450000.0|       3|\n// |Paris|250000.0|       1|\n// | Lyon|200000.0|       2|\n// | Lyon|133000.0|       1|\n// | Nice|325000.0|       3|\n// |Paris|300000.0|       2|\n// |Paris|450000.0|       3|\n// |Paris|250000.0|       1|\n// | Lyon|200000.0|       2|\n// | Lyon|133000.0|       1|\n// | Nice|325000.0|       3|\n// +-----+--------+--------+\n//\n\nThe other way around will not compile, since aptTypedDs2 has only a subset of the fields. \naptTypedDs.union(aptTypedDs2).show().run\n// :28: error: Cannot prove that ApartmentShortInfo can be projected to Apartment. Perhaps not all member names and types of Apartment are the same in ApartmentShortInfo?\n//        aptTypedDs.union(aptTypedDs2).show().run\n//                        ^\n\nFinally, as with project, union will align fields that have same names/types,\nso fields do not have to be in the same order. \nTypedDataset functions and transformations\nFrameless supports many of Spark's functions and transformations. \nHowever, whenever a Spark function does not exist in Frameless, \ncalling .dataset will expose the underlying \nDataset (from org.apache.spark.sql, the original Spark APIs), \nwhere you can use anything that would be missing from the Frameless' API.\nThese are the main imports for Frameless' aggregate and non-aggregate functions.\nimport frameless.functions._                // For literals\nimport frameless.functions.nonAggregate._   // e.g., concat, abs\nimport frameless.functions.aggregate._      // e.g., count, sum, avg\n\nDrop/Replace/Add fields\ndropTupled() drops a single column and results in a tuple-based schema.\naptTypedDs2.dropTupled('price): TypedDataset[(String,Int)]\n// res17: frameless.TypedDataset[(String, Int)] = [_1: string, _2: int]\n\nTo drop a column and specify a new schema use drop().\ncase class CityBeds(city: String, bedrooms: Int)\n// defined class CityBeds\n\nval cityBeds: TypedDataset[CityBeds] = aptTypedDs2.drop[CityBeds] \n// cityBeds: frameless.TypedDataset[CityBeds] = [city: string, bedrooms: int]\n\nOften, you want to replace an existing column with a new value.\nval inflation = aptTypedDs2.withColumnReplaced('price, aptTypedDs2('price) * 2)\n// inflation: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]\n\ninflation.show(2).run()\n// +-----+--------+--------+\n// | city|   price|bedrooms|\n// +-----+--------+--------+\n// |Paris|600000.0|       2|\n// |Paris|900000.0|       3|\n// +-----+--------+--------+\n// only showing top 2 rows\n//\n\nOr use a literal instead.\nimport frameless.functions.lit\n// import frameless.functions.lit\n\naptTypedDs2.withColumnReplaced('price, lit(0.001)) \n// res19: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]\n\nAdding a column using withColumnTupled() results in a tupled-based schema.\naptTypedDs2.withColumnTupled(lit(Array(\"a\",\"b\",\"c\"))).show(2).run()\n// +-----+--------+---+---------+\n// |   _1|      _2| _3|       _4|\n// +-----+--------+---+---------+\n// |Paris|300000.0|  2|[a, b, c]|\n// |Paris|450000.0|  3|[a, b, c]|\n// +-----+--------+---+---------+\n// only showing top 2 rows\n//\n\nSimilarly, withColumn() adds a column and explicitly expects a schema for the result.\ncase class CityBedsOther(city: String, bedrooms: Int, other: List[String])\n// defined class CityBedsOther\n\ncityBeds.\n   withColumn[CityBedsOther](lit(List(\"a\",\"b\",\"c\"))).\n   show(1).run()\n// +-----+--------+---------+\n// | city|bedrooms|    other|\n// +-----+--------+---------+\n// |Paris|       2|[a, b, c]|\n// +-----+--------+---------+\n// only showing top 1 row\n//\n\nTo conditionally change a column use the when/otherwise operation. \nimport frameless.functions.nonAggregate.when\n// import frameless.functions.nonAggregate.when\n\naptTypedDs2.withColumnTupled(\n   when(aptTypedDs2('city) === \"Paris\", aptTypedDs2('price)).\n   when(aptTypedDs2('city) === \"Lyon\", lit(1.1)).\n   otherwise(lit(0.0))).show(8).run()\n// +-----+--------+---+--------+\n// |   _1|      _2| _3|      _4|\n// +-----+--------+---+--------+\n// |Paris|300000.0|  2|300000.0|\n// |Paris|450000.0|  3|450000.0|\n// |Paris|250000.0|  1|250000.0|\n// | Lyon|200000.0|  2|     1.1|\n// | Lyon|133000.0|  1|     1.1|\n// | Nice|325000.0|  3|     0.0|\n// +-----+--------+---+--------+\n//\n\nA simple way to add a column without loosing important schema information is\nto project the entire source schema into a single column using the asCol() method.\nval c = cityBeds.select(cityBeds.asCol, lit(List(\"a\",\"b\",\"c\")))\n// c: frameless.TypedDataset[(CityBeds, List[String])] = [_1: struct, _2: array]\n\nc.show(1).run()\n// +---------+---------+\n// |       _1|       _2|\n// +---------+---------+\n// |[Paris,2]|[a, b, c]|\n// +---------+---------+\n// only showing top 1 row\n//\n\nasCol() is a new method, without a direct equivalent in Spark's Dataset or DataFrame APIs.\nWhen working with Spark's DataFrames, you often select all columns using .select($\"*\", ...). \nIn a way, asCol() is a typed equivalent of $\"*\". \nFinally, note that using select() and asCol(), compared to using withColumn(), avoids the \nneed of an extra case class to define the result schema.\nTo access nested columns, use the colMany() method. \nc.select(c.colMany('_1, 'city), c('_2)).show(2).run()\n// +-----+---------+\n// |   _1|       _2|\n// +-----+---------+\n// |Paris|[a, b, c]|\n// |Paris|[a, b, c]|\n// +-----+---------+\n// only showing top 2 rows\n//\n\nWorking with collections\nimport frameless.functions._\n// import frameless.functions._\n\nimport frameless.functions.nonAggregate._\n// import frameless.functions.nonAggregate._\n\nval t = cityRatio.select(cityRatio('city), lit(List(\"abc\",\"c\",\"d\")))\n// t: frameless.TypedDataset[(String, List[String])] = [_1: string, _2: array]\n\nt.withColumnTupled(\n   arrayContains(t('_2), \"abc\")\n).show(1).run()\n// +-----+-----------+----+\n// |   _1|         _2|  _3|\n// +-----+-----------+----+\n// |Paris|[abc, c, d]|true|\n// +-----+-----------+----+\n// only showing top 1 row\n//\n\nIf accidentally you apply a collection function on a column that is not a collection,\nyou get a compilation error.\nt.withColumnTupled(\n   arrayContains(t('_1), \"abc\")\n)\n// :36: error: no type parameters for method arrayContains: (column: frameless.AbstractTypedColumn[T,C[A]], value: A)(implicit evidence$1: frameless.CatalystCollection[C])column.ThisType[T,Boolean] exist so that it can be applied to arguments (frameless.TypedColumn[(String, List[String]),String], String)\n//  --- because ---\n// argument expression's type is not compatible with formal parameter type;\n//  found   : frameless.TypedColumn[(String, List[String]),String]\n//  required: frameless.AbstractTypedColumn[?T,?C[?A]]\n// \n//           arrayContains(t('_1), \"abc\")\n//           ^\n// :36: error: type mismatch;\n//  found   : frameless.TypedColumn[(String, List[String]),String]\n//  required: frameless.AbstractTypedColumn[T,C[A]]\n//           arrayContains(t('_1), \"abc\")\n//                          ^\n// :36: error: type mismatch;\n//  found   : String(\"abc\")\n//  required: A\n//           arrayContains(t('_1), \"abc\")\n//                                 ^\n// :36: error: Cannot do collection operations on columns of type C.\n//           arrayContains(t('_1), \"abc\")\n//                        ^\n\nCollecting data to the driver\nIn Frameless all Spark actions (such as collect()) are safe.\nTake the first element from a dataset (if the dataset is empty return None).\ncityBeds.headOption.run()\n// res27: Option[CityBeds] = Some(CityBeds(Paris,2))\n\nTake the first n elements.\ncityBeds.take(2).run()\n// res28: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3))\n\ncityBeds.head(3).run()\n// res29: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1))\n\ncityBeds.limit(4).collect().run()\n// res30: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1), CityBeds(Lyon,2))\n\nSorting columns\nOnly column types that can be sorted are allowed to be selected for sorting. \naptTypedDs.orderBy(aptTypedDs('city).asc).show(2).run()\n// +----+-------+--------+--------+\n// |city|surface|   price|bedrooms|\n// +----+-------+--------+--------+\n// |Lyon|     83|200000.0|       2|\n// |Lyon|     45|133000.0|       1|\n// +----+-------+--------+--------+\n// only showing top 2 rows\n//\n\nThe ordering can be changed by selecting .acs or .desc. \naptTypedDs.orderBy(\n   aptTypedDs('city).asc, \n   aptTypedDs('price).desc\n).show(2).run()\n// +----+-------+--------+--------+\n// |city|surface|   price|bedrooms|\n// +----+-------+--------+--------+\n// |Lyon|     83|200000.0|       2|\n// |Lyon|     45|133000.0|       1|\n// +----+-------+--------+--------+\n// only showing top 2 rows\n//\n\nUser Defined Functions\nFrameless supports lifting any Scala function (up to five arguments) to the\ncontext of a particular TypedDataset:\n// The function we want to use as UDF\nval priceModifier =\n    (name: String, price:Double) => if(name == \"Paris\") price * 2.0 else price\n// priceModifier: (String, Double) => Double = \n\nval udf = aptTypedDs.makeUDF(priceModifier)\n// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = \n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))\n// adjustedPrice: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\nadjustedPrice.show().run()\n// +-----+--------+\n// |   _1|      _2|\n// +-----+--------+\n// |Paris|600000.0|\n// |Paris|900000.0|\n// |Paris|500000.0|\n// | Lyon|200000.0|\n// | Lyon|133000.0|\n// | Nice|325000.0|\n// +-----+--------+\n//\n\nGroupBy and Aggregations\nLet's suppose we wanted to retrieve the average apartment price in each city\nval priceByCity = aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('price)))\n// priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\npriceByCity.collect().run()\n// res35: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))\n\nAgain if we try to aggregate a column that can't be aggregated, we get a compilation error\naptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))\n// :35: error: Cannot compute average of type String.\n//        aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))\n//                                                     ^\n\nNext, we combine select and groupBy to calculate the average price/surface ratio per city:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval cityPriceRatio =  aptds.select(aptds('city), aptds('price) / aptds('surface).cast[Double])\n// cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\ncityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()\n// +-----+------------------+\n// |   _1|                _2|\n// +-----+------------------+\n// | Nice| 4391.891891891892|\n// |Paris| 6833.333333333333|\n// | Lyon|2682.5970548862115|\n// +-----+------------------+\n//\n\nWe can also use pivot to further group data on a secondary column.\nFor example, we can compare the average price across cities by number of bedrooms.\ncase class BedroomStats(\n   city: String,\n   AvgPriceBeds1: Option[Double], // Pivot values may be missing, so we encode them using Options\n   AvgPriceBeds2: Option[Double],\n   AvgPriceBeds3: Option[Double],\n   AvgPriceBeds4: Option[Double])\n// defined class BedroomStats\n\nval bedroomStats = aptds.\n   groupBy(aptds('city)).\n   pivot(aptds('bedrooms)).\n   on(1,2,3,4). // We only care for up to 4 bedrooms\n   agg(avg(aptds('price))).\n   as[BedroomStats]  // Typesafe casting\n// bedroomStats: frameless.TypedDataset[BedroomStats] = [city: string, AvgPriceBeds1: double ... 3 more fields]\n\nbedroomStats.show().run()\n// +-----+-------------+-------------+-------------+-------------+\n// | city|AvgPriceBeds1|AvgPriceBeds2|AvgPriceBeds3|AvgPriceBeds4|\n// +-----+-------------+-------------+-------------+-------------+\n// | Nice|         null|         null|     325000.0|         null|\n// |Paris|     250000.0|     300000.0|     450000.0|         null|\n// | Lyon|     133000.0|     200000.0|         null|         null|\n// +-----+-------------+-------------+-------------+-------------+\n//\n\nWith pivot, collecting data preserves typesafety by\nencoding potentially missing columns with Option.\nbedroomStats.collect().run().foreach(println)\n// BedroomStats(Nice,None,None,Some(325000.0),None)\n// BedroomStats(Paris,Some(250000.0),Some(300000.0),Some(450000.0),None)\n// BedroomStats(Lyon,Some(133000.0),Some(200000.0),None,None)\n\nWorking with Optional fields\nOptional fields can be converted to non-optional using getOrElse(). \nval sampleStats = bedroomStats.select(\n   bedroomStats('AvgPriceBeds2).getOrElse(0.0),\n   bedroomStats('AvgPriceBeds3).getOrElse(0.0))\n// sampleStats: frameless.TypedDataset[(Double, Double)] = [_1: double, _2: double]\n\nsampleStats.show().run()   \n// +--------+--------+\n// |      _1|      _2|\n// +--------+--------+\n// |     0.0|325000.0|\n// |300000.0|450000.0|\n// |200000.0|     0.0|\n// +--------+--------+\n//\n\nEntire TypedDataset Aggregation\nWe often want to aggregate the entire TypedDataset and skip the groupBy() clause.\nIn Frameless you can do this using the agg() operator directly on the TypedDataset.\nIn the following example, we compute the average price, the average surface,\nthe minimum surface, and the set of cities for the entire dataset.\ncase class Stats(\n   avgPrice: Double,\n   avgSurface: Double,\n   minSurface: Int,\n   allCities: Vector[String])\n// defined class Stats\n\naptds.agg(\n   avg(aptds('price)),\n   avg(aptds('surface)),\n   min(aptds('surface)),\n   collectSet(aptds('city))\n).as[Stats].show().run()\n// +-----------------+------------------+----------+-------------------+\n// |         avgPrice|        avgSurface|minSurface|          allCities|\n// +-----------------+------------------+----------+-------------------+\n// |276333.3333333333|62.833333333333336|        25|[Paris, Nice, Lyon]|\n// +-----------------+------------------+----------+-------------------+\n//\n\nYou may apply any TypedColumn operation to a TypedAggregate column as well.\nimport frameless.functions._\n// import frameless.functions._\n\naptds.agg(\n   avg(aptds('price)) * min(aptds('surface)).cast[Double], \n   avg(aptds('surface)) * 0.2,\n   litAggr(\"Hello World\")\n).show().run()\n// +-----------------+------------------+-----------+\n// |               _1|                _2|         _3|\n// +-----------------+------------------+-----------+\n// |6908333.333333333|12.566666666666668|Hello World|\n// +-----------------+------------------+-----------+\n//\n\nJoins\ncase class CityPopulationInfo(name: String, population: Int)\n\nval cityInfo = Seq(\n  CityPopulationInfo(\"Paris\", 2229621),\n  CityPopulationInfo(\"Lyon\", 500715),\n  CityPopulationInfo(\"Nice\", 343629)\n)\n\nval citiInfoTypedDS = TypedDataset.create(cityInfo)\n\nHere is how to join the population information to the apartment's dataset:\nval withCityInfo = aptTypedDs.joinInner(citiInfoTypedDS) { aptTypedDs('city) === citiInfoTypedDS('name) }\n// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct, _2: struct]\n\nwithCityInfo.show().run()\n// +--------------------+---------------+\n// |                  _1|             _2|\n// +--------------------+---------------+\n// |[Paris,50,300000....|[Paris,2229621]|\n// |[Paris,100,450000...|[Paris,2229621]|\n// |[Paris,25,250000....|[Paris,2229621]|\n// |[Lyon,83,200000.0,2]|  [Lyon,500715]|\n// |[Lyon,45,133000.0,1]|  [Lyon,500715]|\n// |[Nice,74,325000.0,3]|  [Nice,343629]|\n// +--------------------+---------------+\n//\n\nThe joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].\nWe can then select which information we want to continue to work with:\ncase class AptPriceCity(city: String, aptPrice: Double, cityPopulation: Int)\n// defined class AptPriceCity\n\nwithCityInfo.select(\n   withCityInfo.colMany('_2, 'name), withCityInfo.colMany('_1, 'price), withCityInfo.colMany('_2, 'population)\n).as[AptPriceCity].show().run\n// +-----+--------+--------------+\n// | city|aptPrice|cityPopulation|\n// +-----+--------+--------------+\n// |Paris|300000.0|       2229621|\n// |Paris|450000.0|       2229621|\n// |Paris|250000.0|       2229621|\n// | Lyon|200000.0|        500715|\n// | Lyon|133000.0|        500715|\n// | Nice|325000.0|        343629|\n// +-----+--------+--------------+\n//\n\n"},"TypedDatasetVsSparkDataset.html":{"url":"TypedDatasetVsSparkDataset.html","title":"Comparing TypedDatasets with Spark's Datasets","keywords":"","body":"Comparing TypedDatasets with Spark's Datasets\nGoal:\n  This tutorial compares the standard Spark Datasets API with the one provided by\n  Frameless' TypedDataset. It shows how TypedDatasets allow for an expressive and\n  type-safe api with no compromises on performance.\nFor this tutorial we first create a simple dataset and save it on disk as a parquet file.\nParquet is a popular columnar format and well supported by Spark.\nIt's important to note that when operating on parquet datasets, Spark knows that each column is stored\nseparately, so if we only need a subset of the columns Spark will optimize for this and avoid reading\nthe entire dataset. This is a rather simplistic view of how Spark and parquet work together but it\nwill serve us well for the context of this discussion.\nimport spark.implicits._\n// import spark.implicits._\n\n// Our example case class Foo acting here as a schema\ncase class Foo(i: Long, j: String)\n// defined class Foo\n\n// Assuming spark is loaded and SparkSession is bind to spark\nval initialDs = spark.createDataset( Foo(1, \"Q\") :: Foo(10, \"W\") :: Foo(100, \"E\") :: Nil )\n// initialDs: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\n// Assuming you are on Linux or Mac OS\ninitialDs.write.parquet(\"/tmp/foo\")\n\nval ds = spark.read.parquet(\"/tmp/foo\").as[Foo]\n// ds: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\nds.show()\n// +---+---+\n// |  i|  j|\n// +---+---+\n// |  1|  Q|\n// | 10|  W|\n// |100|  E|\n// +---+---+\n//\n\nThe value ds holds the content of the initialDs read from a parquet file.\nLet's try to only use field i from Foo and see how Spark's Catalyst (the query optimizer)\noptimizes this.\n// Using a standard Spark TypedColumn in select()\nval filteredDs = ds.filter($\"i\" === 10).select($\"i\".as[Long])\n// filteredDs: org.apache.spark.sql.Dataset[Long] = [i: bigint]\n\nfilteredDs.show()\n// +---+\n// |  i|\n// +---+\n// | 10|\n// +---+\n//\n\nThe filteredDs is of type Dataset[Long]. Since we only access field i from Foo the type is correct.\nUnfortunately, this syntax requires handholding by explicitly setting the TypedColumn in the select statement\nto return type Long (look at the as[Long] statement). We will discuss this limitation next in more detail.\nNow, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.\nfilteredDs.explain()\n// == Physical Plan ==\n// *Project [i#1771L]\n// +- *Filter (isnotnull(i#1771L) && (i#1771L = 10))\n//    +- *FileScan parquet [i#1771L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nThe last line is very important (see ReadSchema). The schema read\nfrom the parquet file only required reading column i without needing to access column j.\nThis is great! We have both an optimized query plan and type-safety!\nUnfortunately, this syntax is not bulletproof: it fails at run-time if we try to access\na non existing column x:\nscala> ds.filter($\"i\" === 10).select($\"x\".as[Long])\norg.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];;\n'Project ['x]\n+- Filter (i#1771L = cast(10 as bigint))\n   +- Relation[i#1771L,j#1772] parquet\n\n  at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:88)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:85)\n  at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n  at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n  at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:70)\n  at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:288)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:279)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:289)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1$1.apply(QueryPlan.scala:293)\n  at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n  at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n  at scala.collection.immutable.List.foreach(List.scala:392)\n  at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n  at scala.collection.immutable.List.map(List.scala:296)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:293)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$6.apply(QueryPlan.scala:298)\n  at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:187)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:298)\n  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:268)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:85)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)\n  at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)\n  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)\n  at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)\n  at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)\n  at org.apache.spark.sql.Dataset.(Dataset.scala:165)\n  at org.apache.spark.sql.Dataset.(Dataset.scala:171)\n  at org.apache.spark.sql.Dataset.select(Dataset.scala:1210)\n  ... 454 elided\n\nThere are two things to improve here. First, we would want to avoid the as[Long] casting that we are required\nto type for type-safety. This is clearly an area where we may introduce a bug by casting to an incompatible\ntype. Second, we want a solution where reference to a non existing column name fails at compilation time.\nThe standard Spark Dataset can achieve this using the following syntax.\nds.filter(_.i == 10).map(_.i).show()\n// +-----+\n// |value|\n// +-----+\n// |   10|\n// +-----+\n//\n\nThis looks great! It reminds us the familiar syntax from Scala.\nThe two closures in filter and map are functions that operate on Foo and the\ncompiler will helps us capture all the mistakes we mentioned above.\nscala> ds.filter(_.i == 10).map(_.x).show()\n:20: error: value x is not a member of Foo\n       ds.filter(_.i == 10).map(_.x).show()\n                                  ^\n\nUnfortunately, this syntax does not allow Spark to optimize the code.\nds.filter(_.i == 10).map(_.i).explain()\n// == Physical Plan ==\n// *SerializeFromObject [input[0, bigint, false] AS value#1805L]\n// +- *MapElements , obj#1804: bigint\n//    +- *Filter .apply\n//       +- *DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#1803: $line14.$read$$iw$$iw$$iw$$iw$Foo\n//          +- *FileScan parquet [i#1771L,j#1772] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [], ReadSchema: struct\n\nAs we see from the explained Physical Plan, Spark was not able to optimize our query as before.\nReading the parquet file will required loading all the fields of Foo. This might be ok for\nsmall datasets or for datasets with few columns, but will be extremely slow for most practical\napplications. Intuitively, Spark currently does not have a way to look inside the code we pass in these two\nclosures. It only knows that they both take one argument of type Foo, but it has no way of knowing if\nwe use just one or all of Foo's fields.\nThe TypedDataset in Frameless solves this problem. It allows for a simple and type-safe syntax\nwith a fully optimized query plan.\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport frameless.syntax._\n// import frameless.syntax._\n\nval fds = TypedDataset.create(ds)\n// fds: frameless.TypedDataset[Foo] = [i: bigint, j: string]\n\nfds.filter(fds('i) === 10).select(fds('i)).show().run()\n// +---+\n// | _1|\n// +---+\n// | 10|\n// +---+\n//\n\nAnd the optimized Physical Plan:\nfds.filter(fds('i) === 10).select(fds('i)).explain()\n// == Physical Plan ==\n// *Project [i#1771L AS _1#1876L]\n// +- *Filter (isnotnull(i#1771L) && (i#1771L = 10))\n//    +- *FileScan parquet [i#1771L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nAnd the compiler is our friend.\nscala> fds.filter(fds('i) === 10).select(fds('x))\n:24: error: No column Symbol with shapeless.tag.Tagged[String(\"x\")] of type A in Foo\n       fds.filter(fds('i) === 10).select(fds('x))\n                                            ^\n\nDifferences in Encoders\nEncoders in Spark's Datasets are partially type-safe. If you try to create a Dataset using  a type that is not \n a Scala Product then you get a compilation error:\nclass Bar(i: Int)\n// defined class Bar\n\nBar is neither a case class nor a Product, so the following correctly gives a compilation error in Spark:\nscala> spark.createDataset(Seq(new Bar(1)))\n:24: error: Unable to find encoder for type stored in a Dataset.  Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._  Support for serializing other types will be added in future releases.\n       spark.createDataset(Seq(new Bar(1)))\n                          ^\n\nHowever, the compile type guards implemented in Spark are not sufficient to detect non encodable members. \nFor example, using the following case class leads to a runtime failure:\ncase class MyDate(jday: java.util.Date)\n// defined class MyDate\n\nval myDateDs = spark.createDataset(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// java.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n// - field (class: \"java.util.Date\", name: \"jday\")\n// - root class: \"MyDate\"\n//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:632)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:455)\n//   at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:56)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$class.cleanUpReflectionObjects(ScalaReflection.scala:809)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:39)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:455)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1$$anonfun$10.apply(ScalaReflection.scala:626)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1$$anonfun$10.apply(ScalaReflection.scala:614)\n//   at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n//   at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n//   at scala.collection.immutable.List.foreach(List.scala:392)\n//   at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n//   at scala.collection.immutable.List.flatMap(List.scala:355)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:614)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:455)\n//   at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:56)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$class.cleanUpReflectionObjects(ScalaReflection.scala:809)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:39)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:455)\n//   at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:444)\n//   at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:71)\n//   at org.apache.spark.sql.Encoders$.product(Encoders.scala:275)\n//   at org.apache.spark.sql.LowPrioritySQLImplicits$class.newProductEncoder(SQLImplicits.scala:233)\n//   at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:33)\n//   ... 770 elided\n\nIn comparison, a TypedDataset will notify about the encoding problem at compile time: \nTypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// :25: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[MyDate]\n//        TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n//                           ^\n\nAggregate vs Projected columns\nSpark's Dataset do not distinguish between columns created from aggregate operations, \nsuch as summing or averaging, and simple projections/selections. \nThis is problematic when you start mixing the two.\nimport org.apache.spark.sql.functions.sum\n// import org.apache.spark.sql.functions.sum\n\nds.select(sum($\"i\"), $\"i\"*2)\n// org.apache.spark.sql.AnalysisException: grouping expressions sequence is empty, and '`i`' is not an aggregate function. Wrap '(sum(`i`) AS `sum(i)`)' in windowing function(s) or wrap '`i`' in first() (or first_value) if you don't care which value you get.;;\n// Aggregate [sum(i#1771L) AS sum(i)#1889L, (i#1771L * cast(2 as bigint)) AS (i * 2)#1890L]\n// +- Relation[i#1771L,j#1772] parquet\n// \n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.failAnalysis(CheckAnalysis.scala:39)\n//   at org.apache.spark.sql.catalyst.analysis.Analyzer.failAnalysis(Analyzer.scala:91)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1(CheckAnalysis.scala:239)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)\n//   at scala.collection.immutable.List.foreach(List.scala:392)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1(CheckAnalysis.scala:253)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)\n//   at scala.collection.immutable.List.foreach(List.scala:392)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1(CheckAnalysis.scala:253)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$9.apply(CheckAnalysis.scala:280)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$9.apply(CheckAnalysis.scala:280)\n//   at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)\n//   at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:280)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)\n//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)\n//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)\n//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)\n//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)\n//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:67)\n//   at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2884)\n//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1150)\n//   ... 854 elided\n\nIn Frameless, mixing the two results in a compilation error.\n// To avoid confusing frameless' sum with the standard Spark's sum\nimport frameless.functions.aggregate.{sum => fsum}\n// import frameless.functions.aggregate.{sum=>fsum}\n\nfds.select(fsum(fds('i)))\n// :26: error: polymorphic expression cannot be instantiated to expected type;\n//  found   : [Out]frameless.TypedAggregate[Foo,Out]\n//  required: frameless.TypedColumn[Foo,?]\n//        fds.select(fsum(fds('i)))\n//                       ^\n\nAs the error suggests, we expected a TypedColumn but we got a TypedAggregate instead. \nHere is how you apply an aggregation method in Frameless: \nfds.agg(fsum(fds('i))+22).show().run()\n// +---+\n// | _1|\n// +---+\n// |133|\n// +---+\n//\n\nSimilarly, mixing projections while aggregating does not make sense, and in Frameless\nyou get a compilation error.  \nfds.agg(fsum(fds('i)), fds('i)).show().run()\n// :26: error: polymorphic expression cannot be instantiated to expected type;\n//  found   : [A]frameless.TypedColumn[Foo,A]\n//  required: frameless.TypedAggregate[Foo,?]\n//        fds.agg(fsum(fds('i)), fds('i)).show().run()\n//                                  ^\n\n"},"TypedEncoder.html":{"url":"TypedEncoder.html","title":"Typed Encoders in Frameless","keywords":"","body":"Typed Encoders in Frameless\nSpark uses Reflection to derive its Encoders, which is why they can fail at run time. For example, because Spark does not support java.util.Date, the following leads to an error:\nimport org.apache.spark.sql.Dataset\nimport spark.implicits._\n\ncase class DateRange(s: java.util.Date, e: java.util.Date)\n\nscala> val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))\n:24: error: not found: value sqlContext\n       val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))\n                                    ^\n\nAs shown by the stack trace, this runtime error goes through ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection-based approach is its inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.\nFrameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every Frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless' type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the java.util.Date example won't compile with Frameless:\nimport frameless.TypedDataset\nimport frameless.syntax._\n\nval ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// :28: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]\n//        val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n//                                                             ^\n\nType class derivation takes care of recursively constructing (and proving the existence of) TypeEncoders for case classes. The following works as expected:\ncase class Bar(d: Double, s: String)\n// defined class Bar\n\ncase class Foo(i: Int, b: Bar)\n// defined class Foo\n\nval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, \"s\"))))\n// ds: frameless.TypedDataset[Foo] = [i: int, b: struct]\n\nds.collect()\n// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@558c6c17\n\nBut any non-encodable in the case class hierarchy will be detected at compile time:\ncase class BarDate(d: Double, s: String, t: java.util.Date)\ncase class FooDate(i: Int, b: BarDate)\n\nval ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// :30: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]\n//        val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n//                                                           ^\n\nIt should be noted that once derived, reflection-based Encoders and implicitly derived TypeEncoders have identical performance. The derivation mechanism is different, but the objects generated to encode and decode JVM objects in Spark's internal representation behave the same at runtime.\n"},"Injection.html":{"url":"Injection.html","title":"Injection: Creating Custom Encoders","keywords":"","body":"Injection: Creating Custom Encoders\nInjection lets us define encoders for types that do not have one by injecting A into an encodable type B.\nThis is the definition of the injection typeclass:\ntrait Injection[A, B] extends Serializable {\n  def apply(a: A): B\n  def invert(b: B): A\n}\n\nExample\nLet's define a simple case class:\ncase class Person(age: Int, birthday: java.util.Date)\n// defined class Person\n\nval people = Seq(Person(42, new java.util.Date))\n// people: Seq[Person] = List(Person(42,Sun Feb 18 15:18:58 PST 2018))\n\nAnd an instance of a TypedDataset:\nval personDS = TypedDataset.create(people)\n// :23: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n//        val personDS = TypedDataset.create(people)\n//                                          ^\n\nLooks like we can't, a TypedEncoder instance of Person is not available, or more precisely for java.util.Date.\nBut we can define a injection from java.util.Date to an encodable type, like Long:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = new Injection[java.util.Date, Long] {\n  def apply(d: java.util.Date): Long = d.getTime()\n  def invert(l: Long): java.util.Date = new java.util.Date(l)\n}\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@37f23430\n\nWe can be less verbose using the Injection.apply function:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@6cd20faa\n\nNow we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, birthday: bigint]\n\nAnother example\nLet's define a sealed family:\nsealed trait Gender\n// defined trait Gender\n\ncase object Male extends Gender\n// defined object Male\n\ncase object Female extends Gender\n// defined object Female\n\ncase object Other extends Gender\n// defined object Other\n\nAnd a simple case class:\ncase class Person(age: Int, gender: Gender)\n// defined class Person\n\nval people = Seq(Person(42, Male))\n// people: Seq[Person] = List(Person(42,Male))\n\nAgain if we try to create a TypedDataset, we get a compilation error.\nval personDS = TypedDataset.create(people)\n// :31: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n//        val personDS = TypedDataset.create(people)\n//                                          ^\n\nLet's define an injection instance for Gender:\nimplicit val genderToInt: Injection[Gender, Int] = Injection(\n  {\n    case Male   => 1\n    case Female => 2\n    case Other  => 3\n  },\n  {\n    case 1 => Male\n    case 2 => Female\n    case 3 => Other\n  })\n// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@4d1cf7ad\n\nAnd now we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, gender: int]\n\n"},"Job.html":{"url":"Job.html","title":"Job[A]","keywords":"","body":"Job[A]\nAll operations on TypedDataset are lazy. An operation either returns a new\ntransformed TypedDataset or an F[A], where F[_] is a type constructor\nwith an instance of the SparkDelay typeclass and A is the result of running a\nnon-lazy computation in Spark. \nA default such type constructor called Job is provided by Frameless. \nJob serves several functions:\n\nMakes all operations on a TypedDataset lazy, which makes them more predictable compared to having\nfew operations being lazy and other being strict\nAllows the programmer to make expensive blocking operations explicit\nAllows for Spark jobs to be lazily sequenced using monadic composition via for-comprehension\nProvides an obvious place where you can annotate/name your Spark jobs to make it easier\nto track different parts of your application in the Spark UI\n\nThe toy example showcases the use of for-comprehension to explicitly sequences Spark Jobs.\nFirst we calculate the size of the TypedDataset and then we collect to the driver\nexactly 20% of its elements:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval ds = TypedDataset.create(1 to 20)\n// ds: frameless.TypedDataset[Int] = [_1: int]\n\nval countAndTakeJob =\n  for {\n    count \nThe countAndTakeJob can either be executed using run() (as we show above) or it can\nbe passed along to other parts of the program to be further composed into more complex sequences\nof Spark jobs.\nimport frameless.Job\n// import frameless.Job\n\ndef computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min)\n// computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]\n\nval finalJob = computeMinOfSample(countAndTakeJob)\n// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@30c69a34\n\nNow we can execute this new job by specifying a group-id and a description.\nThis allows the programmer to see this information on the Spark UI and help track, say,\nperformance issues.\nfinalJob.\n  withGroupId(\"samplingJob\").\n  withDescription(\"Samples 20% of elements and computes the min\").\n  run()\n// res2: Int = 1\n\nMore on SparkDelay\nAs mentioned above, SparkDelay[F[_]] is a typeclass required for suspending\neffects by Spark computations. This typeclass represents the ability to suspend\nan => A thunk into an F[A] value, while implicitly capturing a SparkSession.\nAs it is a typeclass, it is open for implementation by the user in order to use\nother data types for suspension of effects. The cats module, for example, uses\nthis typeclass to support suspending Spark computations in any effect type that\nhas a cats.effect.Sync instance.\n"},"Cats.html":{"url":"Cats.html","title":"Using Cats with RDDs","keywords":"","body":"Using Cats with Frameless\nThere are two main parts to the cats integration offered by Frameless:\n\neffect suspension in TypedDataset using cats-effect and cats-mtl\nRDD enhancements using algebraic typeclasses in cats-kernel\n\nAll the examples below assume you have previously imported cats.implicits and frameless.cats.implicits.\nNote that you should not import frameless.syntax._ together with frameless.cats.implicits._.\nimport cats.implicits._\n// import cats.implicits._\n\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nEffect Suspension in typed datasets\nAs noted in the section about Job, all operations on TypedDataset are lazy. The results of \noperations that would normally block on plain Spark APIs are wrapped in a type constructor F[_], \nfor which there exists an instance of SparkDelay[F]. This typeclass represents the operation of \ndelaying a computation and capturing an implicit SparkSession. \nIn the cats module, we utilize the typeclasses from cats-effect for abstracting over these \neffect types - namely, we provide an implicit SparkDelay instance for all F[_] for which exists\nan instance of cats.effect.Sync[F].\nThis allows one to run operations on TypedDataset in an existing monad stack. For example, given\nthis pre-existing monad stack:\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport cats.data.ReaderT\n// import cats.data.ReaderT\n\nimport cats.effect.IO\n// import cats.effect.IO\n\nimport cats.effect.implicits._\n// import cats.effect.implicits._\n\ntype Action[T] = ReaderT[IO, SparkSession, T]\n// defined type alias Action\n\nWe will be able to request that values from TypedDataset will be suspended in this stack:\nval typedDs = TypedDataset.create(Seq((1, \"string\"), (2, \"another\")))\n// typedDs: frameless.TypedDataset[(Int, String)] = [_1: int, _2: string]\n\nval result: Action[(Seq[(Int, String)], Long)] = for {\n  sample )\n\nAs with Job, note that nothing has been run yet. The effect has been properly suspended. To\nrun our program, we must first supply the SparkSession to the ReaderT layer and then\nrun the IO effect:\nresult.run(spark).unsafeRunSync()\n// res5: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)\n\nConvenience methods for modifying Spark thread-local variables\nThe frameless.cats.implicits._ import also provides some syntax enrichments for any monad\nstack that has the same capabilities as Action above. Namely, the ability to provide an\ninstance of SparkSession and the ability to suspend effects.\nFor these to work, we will need to import the implicit machinery from the cats-mtl library:\nimport cats.mtl.implicits._\n// import cats.mtl.implicits._\n\nAnd now, we can set the description for the computation being run:\nval resultWithDescription: Action[(Seq[(Int, String)], Long)] = for {\n  r )\n\nresultWithDescription.run(spark).unsafeRunSync()\n// Description: fancy cats\n// res6: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)\n\nUsing algebraic typeclasses from Cats with RDDs\nData aggregation is one of the most important operations when working with Spark (and data in general).\nFor example, we often have to compute the min, max, avg, etc. from a set of columns grouped by\ndifferent predicates. This section shows how cats simplifies these tasks in Spark by\nleveraging a large collection of Type Classes for ordering and aggregating data.\nCats offers ways to sort and aggregate tuples of arbitrary arity.\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nval data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[14] at makeRDD at :44\n\nprintln(data.csum)\n// (10,9,9)\n\nprintln(data.cmax)\n// (8,2,3)\n\nprintln(data.cmin)\n// (1,2,3)\n\nIn case the RDD is empty, the csum, cmax and cmin will use the default values for the type of\nelements inside the RDD. There are counterpart operations to those that have an Option return type\nto deal with the case of an empty RDD:\nval data: RDD[(Int, Int, Int)] = sc.emptyRDD\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = EmptyRDD[15] at emptyRDD at :44\n\nprintln(data.csum)\n// (0,0,0)\n\nprintln(data.csumOption)\n// None\n\nprintln(data.cmax)\n// (0,0,0)\n\nprintln(data.cmaxOption)\n// None\n\nprintln(data.cmin)\n// (0,0,0)\n\nprintln(data.cminOption)\n// None\n\nThe following example aggregates all the elements with a common key.\ntype User = String\n// defined type alias User\n\ntype TransactionCount = Int\n// defined type alias TransactionCount\n\nval allData: RDD[(User,TransactionCount)] =\n   sc.makeRDD((\"Bob\", 12) :: (\"Joe\", 1) :: (\"Anna\", 100) :: (\"Bob\", 20) :: (\"Joe\", 2) :: Nil)\n// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[16] at makeRDD at :47\n\nval totalPerUser =  allData.csumByKey\n// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[17] at reduceByKey at implicits.scala:42\n\ntotalPerUser.collectAsMap\n// res16: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)\n\nThe same example would work for more complex keys.\nimport scala.collection.immutable.SortedMap\n// import scala.collection.immutable.SortedMap\n\nval allDataComplexKeu =\n   sc.makeRDD( (\"Bob\", SortedMap(\"task1\" -> 10)) ::\n    (\"Joe\", SortedMap(\"task1\" -> 1, \"task2\" -> 3)) :: (\"Bob\", SortedMap(\"task1\" -> 10, \"task2\" -> 1)) :: (\"Joe\", SortedMap(\"task3\" -> 4)) :: Nil )\n// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ParallelCollectionRDD[18] at makeRDD at :46\n\nval overalTasksPerUser = allDataComplexKeu.csumByKey\n// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ShuffledRDD[19] at reduceByKey at implicits.scala:42\n\noveralTasksPerUser.collectAsMap\n// res17: scala.collection.Map[String,scala.collection.immutable.SortedMap[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))\n\nJoins\n// Type aliases for meaningful types\ntype TimeSeries = Map[Int,Int]\n// defined type alias TimeSeries\n\ntype UserName = String\n// defined type alias UserName\n\nExample: Using the implicit full-our-join operator\nimport frameless.cats.outer._\n// import frameless.cats.outer._\n\nval day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 2, 1 -> 4)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Sam\", Map(0 -> 1)) :: Nil )\n// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[20] at makeRDD at :50\n\nval day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 10, 1 -> 11)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Joe\", Map(0 -> 1, 1 -> 2)) :: Nil )\n// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[21] at makeRDD at :50\n\nval daysCombined = day1 |+| day2\n// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[25] at mapValues at implicits.scala:67\n\ndaysCombined.collect()\n// res19: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))\n\nNote how the user's timeseries from different days have been aggregated together.\nThe |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join\non the key and combine values using the default Semigroup for the value type.\nIn cats:\nMap(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)\n// res20: Map[Int,Int] = Map(1 -> 6, 2 -> 2)\n\n"},"TypedML.html":{"url":"TypedML.html","title":"Using Spark ML with TypedDataset","keywords":"","body":"Typed Spark ML\nThe frameless-ml module provides a strongly typed Spark ML API leveraging TypedDatasets. It introduces TypedTransformers\nand TypedEstimators, the type-safe equivalents of Spark ML's Transformer and Estimator. \nA TypedEstimator fits models to data, i.e trains a ML model based on an input TypedDataset. \nA TypedTransformer transforms one TypedDataset into another, usually by appending column(s) to it.\nBy calling the fit method of a TypedEstimator, the TypedEstimator will train a ML model using the TypedDataset \npassed as input (representing the training data) and will return a TypedTransformer that represents the trained model. \nThis TypedTransformercan then be used to make predictions on an input TypedDataset (representing the test data) \nusing the transform method that will return a new TypedDataset with appended prediction column(s).\nBoth TypedEstimator and TypedTransformer check at compile-time the correctness of their inputs field names and types,\ncontrary to Spark ML API which only deals with DataFrames (the data structure with the lowest level of type-safety in Spark).\nframeless-ml adds type-safety to Spark ML API but stays very close to it in terms of abstractions and API calls, so \nplease check Spark ML documentation for more details \non Transformers and Estimators.\nExample 1: predict a continuous value using a TypedRandomForestRegressor\nIn this example, we want to predict the sale price of a house depending on its square footage and the fact that the house\nhas a garden or not. We will use a TypedRandomForestRegressor.\nTraining\nAs with the Spark ML API, we use a TypedVectorAssembler (the type-safe equivalent of VectorAssembler)\nto compute feature vectors:\nimport frameless._\nimport frameless.syntax._\nimport frameless.ml._\nimport frameless.ml.feature._\nimport frameless.ml.regression._\nimport org.apache.spark.ml.linalg.Vector\n\ncase class HouseData(squareFeet: Double, hasGarden: Boolean, price: Double)\n// defined class HouseData\n\nval trainingData = TypedDataset.create(Seq(\n  HouseData(20, false, 100000),\n  HouseData(50, false, 200000),\n  HouseData(50, true, 250000),\n  HouseData(100, true, 500000)\n))\n// trainingData: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]\n\ncase class Features(squareFeet: Double, hasGarden: Boolean)\n// defined class Features\n\nval assembler = TypedVectorAssembler[Features]\n// assembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@159b3f1\n\ncase class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector)\n// defined class HouseDataWithFeatures\n\nval trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures]\n// trainingDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]\n\nIn the above code snippet, .as[HouseDataWithFeatures] is a TypedDataset's type-safe cast\n(see TypedDataset: Feature Overview):\ncase class WrongHouseFeatures(\n  squareFeet: Double,\n  hasGarden: Int, // hasGarden has wrong type\n  price: Double,\n  features: Vector\n)\n\nassembler.transform(trainingData).as[WrongHouseFeatures]\n// :39: error: could not find implicit value for parameter as: frameless.ops.As[(Double, Boolean, Double, org.apache.spark.ml.linalg.Vector),WrongHouseFeatures]\n//        assembler.transform(trainingData).as[WrongHouseFeatures]\n//                                            ^\n\nMoreover, TypedVectorAssembler[Features] will compile only if Features contains exclusively fields of type Numeric or Boolean:\ncase class WrongFeatures(squareFeet: Double, hasGarden: Boolean, city: String)\n\nTypedVectorAssembler[WrongFeatures]\n// :37: error: Cannot prove that WrongFeatures is a valid input type. Input type must only contain fields of numeric or boolean types.\n//        TypedVectorAssembler[WrongFeatures]\n//                            ^\n\nThe subsequent call assembler.transform(trainingData) compiles only if trainingData contains all fields (names and types)\nof Features:\ncase class WrongHouseData(squareFeet: Double, price: Double) // hasGarden is missing\n// defined class WrongHouseData\n\nval wrongTrainingData = TypedDataset.create(Seq(WrongHouseData(20, 100000)))\n// wrongTrainingData: frameless.TypedDataset[WrongHouseData] = [squareFeet: double, price: double]\n\nassembler.transform(wrongTrainingData)\n// :37: error: Cannot prove that WrongHouseData can be projected to Features. Perhaps not all member names and types of Features are the same in WrongHouseData?\n//        assembler.transform(wrongTrainingData)\n//                           ^\n\nThen, we train the model. To train a Random Forest, one needs to feed it with features (what we predict from) and\nwith a label (what we predict). In our example, price is the label, features are the features:\ncase class RFInputs(price: Double, features: Vector)\n// defined class RFInputs\n\nval rf = TypedRandomForestRegressor[RFInputs]\n// rf: frameless.ml.regression.TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@4c620c93\n\nval model = rf.fit(trainingDataWithFeatures).run()\n// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.regression.TypedRandomForestRegressor.Outputs,org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anonfun$fit$1$$anon$1@36ed2d44\n\nTypedRandomForestRegressor[RFInputs] compiles only if RFInputs\ncontains only one field of type Double (the label) and one field of type Vector (the features):\ncase class WrongRFInputs(labelOfWrongType: String, features: Vector)\n\nTypedRandomForestRegressor[WrongRFInputs]\n// :37: error: Cannot prove that WrongRFInputs is a valid input type. Input type must only contain a field of type Double (the label) and a field of type org.apache.spark.ml.linalg.Vector (the features).\n//        TypedRandomForestRegressor[WrongRFInputs]\n//                                  ^\n\nThe subsequent rf.fit(trainingDataWithFeatures) call compiles only if trainingDataWithFeatures contains the same fields\n(names and types) as RFInputs.\nval wrongTrainingDataWithFeatures = TypedDataset.create(Seq(HouseData(20, false, 100000))) // features are missing\n// wrongTrainingDataWithFeatures: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]\n\nrf.fit(wrongTrainingDataWithFeatures) \n// :37: error: Cannot prove that HouseData can be projected to RFInputs. Perhaps not all member names and types of RFInputs are the same in HouseData?\n//        rf.fit(wrongTrainingDataWithFeatures)\n//              ^\n\nPrediction\nWe now want to predict price for testData using the previously trained model. Like the Spark ML API,\ntestData has a default value for price (0 in our case) that will be ignored at prediction time. We reuse\nour assembler to compute the feature vector of testData.\nval testData = TypedDataset.create(Seq(HouseData(70, true, 0)))\n// testData: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]\n\nval testDataWithFeatures = assembler.transform(testData).as[HouseDataWithFeatures]\n// testDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]\n\ncase class HousePricePrediction(\n  squareFeet: Double,\n  hasGarden: Boolean,\n  price: Double,\n  features: Vector,\n  predictedPrice: Double\n)\n// defined class HousePricePrediction\n\nval predictions = model.transform(testDataWithFeatures).as[HousePricePrediction]\n// predictions: frameless.TypedDataset[HousePricePrediction] = [squareFeet: double, hasGarden: boolean ... 3 more fields]\n\npredictions.select(predictions.col('predictedPrice)).collect.run()\n// res6: Seq[Double] = WrappedArray(420000.0)\n\nmodel.transform(testDataWithFeatures) will only compile if testDataWithFeatures contains a field price of type Double\nand a field features of type Vector:\nmodel.transform(testData)\n// :37: error: Cannot prove that HouseData can be projected to RFInputs. Perhaps not all member names and types of RFInputs are the same in HouseData?\n//        model.transform(testData)\n//                       ^\n\nExample 2: predict a categorical value using a TypedRandomForestClassifier\nIn this example, we want to predict in which city a house is located depending on its price and its square footage. We use a\nTypedRandomForestClassifier.\nTraining\nAs with the Spark ML API, we use a TypedVectorAssembler to compute feature vectors and a TypedStringIndexer\nto index city values in order to be able to pass them to a TypedRandomForestClassifier\n(which only accepts Double values as label):\nimport frameless.ml.classification._\n\ncase class HouseData(squareFeet: Double, city: String, price: Double)\n// defined class HouseData\n\nval trainingData = TypedDataset.create(Seq(\n  HouseData(100, \"lyon\", 100000),\n  HouseData(200, \"lyon\", 200000),\n  HouseData(100, \"san francisco\", 500000),\n  HouseData(150, \"san francisco\", 900000)\n))\n// trainingData: frameless.TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]\n\ncase class Features(price: Double, squareFeet: Double)\n// defined class Features\n\nval vectorAssembler = TypedVectorAssembler[Features]\n// vectorAssembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@66b12f1\n\ncase class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector)\n// defined class HouseDataWithFeatures\n\nval dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures]\n// dataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]\n\ncase class StringIndexerInput(city: String)\n// defined class StringIndexerInput\n\nval indexer = TypedStringIndexer[StringIndexerInput]\n// indexer: frameless.ml.feature.TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@666bcbec\n\nval indexerModel = indexer.fit(dataWithFeatures).run()\n// indexerModel: frameless.ml.AppendTransformer[StringIndexerInput,frameless.ml.feature.TypedStringIndexer.Outputs,org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anonfun$fit$1$$anon$1@5a0797e\n\ncase class HouseDataWithFeaturesAndIndex(\n  squareFeet: Double,\n  city: String,\n  price: Double,\n  features: Vector,\n  cityIndexed: Double\n)\n// defined class HouseDataWithFeaturesAndIndex\n\nval indexedData = indexerModel.transform(dataWithFeatures).as[HouseDataWithFeaturesAndIndex]\n// indexedData: frameless.TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]\n\nThen, we train the model:\ncase class RFInputs(cityIndexed: Double, features: Vector)\n// defined class RFInputs\n\nval rf = TypedRandomForestClassifier[RFInputs]\n// rf: frameless.ml.classification.TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@be7eeed\n\nval model = rf.fit(indexedData).run()\n// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.classification.TypedRandomForestClassifier.Outputs,org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anonfun$fit$1$$anon$1@20355c2f\n\nPrediction\nWe now want to predict city for testData using the previously trained model. Like the Spark ML API,\ntestData has a default value for city (empty string in our case) that will be ignored at prediction time. We reuse\nour vectorAssembler to compute the feature vector of testData and our indexerModel to index city.\nval testData = TypedDataset.create(Seq(HouseData(120, \"\", 800000)))\n// testData: frameless.TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]\n\nval testDataWithFeatures = vectorAssembler.transform(testData).as[HouseDataWithFeatures]\n// testDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]\n\nval indexedTestData = indexerModel.transform(testDataWithFeatures).as[HouseDataWithFeaturesAndIndex]\n// indexedTestData: frameless.TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]\n\ncase class HouseCityPredictionInputs(features: Vector, cityIndexed: Double)\n// defined class HouseCityPredictionInputs\n\nval testInput = indexedTestData.project[HouseCityPredictionInputs]\n// testInput: frameless.TypedDataset[HouseCityPredictionInputs] = [features: vector, cityIndexed: double]\n\ncase class HouseCityPredictionIndexed(\n  features: Vector,\n  cityIndexed: Double,\n  rawPrediction: Vector,\n  probability: Vector,\n  predictedCityIndexed: Double\n)\n// defined class HouseCityPredictionIndexed\n\nval indexedPredictions = model.transform(testInput).as[HouseCityPredictionIndexed]\n// indexedPredictions: frameless.TypedDataset[HouseCityPredictionIndexed] = [features: vector, cityIndexed: double ... 3 more fields]\n\nThen, we use a TypedIndexToString to get back a String value from predictedCityIndexed. TypedIndexToString takes\nas input the label array computed by our previous indexerModel:\ncase class IndexToStringInput(predictedCityIndexed: Double)\n// defined class IndexToStringInput\n\nval indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)\n// indexToString: frameless.ml.feature.TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@c97d749\n\ncase class HouseCityPrediction(\n  features: Vector,\n  cityIndexed: Double,\n  rawPrediction: Vector,\n  probability: Vector,\n  predictedCityIndexed: Double,\n  predictedCity: String\n)\n// defined class HouseCityPrediction\n\nval predictions = indexToString.transform(indexedPredictions).as[HouseCityPrediction]\n// predictions: frameless.TypedDataset[HouseCityPrediction] = [features: vector, cityIndexed: double ... 4 more fields]\n\npredictions.select(predictions.col('predictedCity)).collect.run()\n// res8: Seq[String] = WrappedArray(san francisco)\n\nList of currently implemented TypedEstimators\n\nTypedRandomForestClassifier\nTypedRandomForestRegressor\n... your contribution here ... :)\n\nList of currently implemented TypedTransformers\n\nTypedIndexToString\nTypedStringIndexer\nTypedVectorAssembler\n... your contribution here ... :)\n\nUsing Vector and Matrix with TypedDataset\nframeless-ml provides TypedEncoder instances for org.apache.spark.ml.linalg.Vector \nand org.apache.spark.ml.linalg.Matrix:\nimport frameless._\nimport frameless.ml._\nimport org.apache.spark.ml.linalg._\n\nval vector = Vectors.dense(1, 2, 3)\n// vector: org.apache.spark.ml.linalg.Vector = [1.0,2.0,3.0]\n\nval vectorDs = TypedDataset.create(Seq(\"label\" -> vector))\n// vectorDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Vector)] = [_1: string, _2: vector]\n\nval matrix = Matrices.dense(2, 1, Array(1, 2))\n// matrix: org.apache.spark.ml.linalg.Matrix =\n// 1.0\n// 2.0\n\nval matrixDs = TypedDataset.create(Seq(\"label\" -> matrix))\n// matrixDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Matrix)] = [_1: string, _2: matrix]\n\nUnder the hood, Vector and Matrix are encoded using org.apache.spark.ml.linalg.VectorUDT \nand org.apache.spark.ml.linalg.MatrixUDT. This is possible thanks to the implicit derivation \nfrom org.apache.spark.sql.types.UserDefinedType[A] to TypedEncoder[A] defined in TypedEncoder companion object.\n"},"TypedDataFrame.html":{"url":"TypedDataFrame.html","title":"Proof of Concept: TypedDataFrame","keywords":"","body":"Proof of Concept: TypedDataFrame\nTypedDataFrame is the API developed in the early stages of Frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future development of Frameless. However, the design is interesting enough to document.\nTo safely manipulate DataFrames we use a technique called a shadow type, which consists in storing additional information about a value in a \"dummy\" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.\nDiving in\nIn TypedDataFrame, we use a single Schema  to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:\nimport org.apache.spark.sql.DataFrame\nimport shapeless.HList\n\nclass TDataFrame[Schema  Boolean): TDataFrame[Schema] = ???\n\n  def select[C \nAs you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.\nType-level column referencing\nFor Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching invalid column references compile type. When everything goes well, Frameless select is very similar to vanilla select, except that it keeps track of the selected column types:\nimport frameless.TypedDataFrame\n\ncase class Foo(s: String, d: Double, i: Int)\n\ndef selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n  tf.select('i, 's)\n\nHowever, in case of typo, it gets caught right away:\ndef selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n  tf.select('j, 's)\n\nType-level joins\nJoins can available with two different syntaxes. The first lets you reference different columns on each TypedDataFrame, and ensures that they all exist and have compatible types:\ncase class Bar(i: Int, j: String, b: Boolean)\n\ndef join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n    : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =\n  tf1.innerJoin(tf2).on('s).and('j)\n\nThe second syntax brings some convenience when the joining columns have identical names in both tables:\ndef join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n    : TypedDataFrame[(String, Double, Int, String, Boolean)] =\n  tf1.innerJoin(tf2).using('i)\n\nFurther example are available in the TypedDataFrame join tests.\nComplete example\nWe now consider a complete example to see how the Frameless types can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city maps and neighborhoods:\ntype Neighborhood = String\ntype Address = String\n\ncase class PhoneBookEntry(\n  address: Address,\n  residents: String,\n  phoneNumber: Double\n)\n\ncase class CityMapEntry(\n  address: Address,\n  neighborhood: Neighborhood\n)\n\nOur goal will be to compute the neighborhood with unique names, approximating \"unique\" with names containing less common\nletters in the alphabet: 'x', 'q', and 'z'. We are going to need a natural language processing library at some point, so\nlet's use the following for the example:\nobject NLPLib {\n  def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))\n}\n\nSuppose we manage to obtain public data for a TypedDataFrame[PhoneBookEntry] and TypedDataFrame[CityMapEntry]. Here is what our Spark job could look like with Frameless:\nimport org.apache.spark.sql.SQLContext\n\n// These case classes are used to hold intermediate results\ncase class Family(residents: String, neighborhood: Neighborhood)\ncase class Person(name: String, neighborhood: Neighborhood)\ncase class NeighborhoodCount(neighborhood: Neighborhood, count: Long)\n\ndef bestNeighborhood\n  (phoneBookTF: TypedDataFrame[PhoneBookEntry], cityMapTF: TypedDataFrame[CityMapEntry])\n  (implicit c: SQLContext): String = {\n                                          (((((((((\n  phoneBookTF\n    .innerJoin(cityMapTF).using('address) :TypedDataFrame[(Address, String, Double, String)])\n    .select('_2, '_4)                     :TypedDataFrame[(String, String)])\n    .as[Family]()                         :TypedDataFrame[Family])\n    .flatMap { f =>\n      f.residents.split(' ').map(r => Person(r, f.neighborhood))\n    }                                     :TypedDataFrame[Person])\n    .filter { p =>\n      NLPLib.uniqueName(p.name)\n    }                                     :TypedDataFrame[Person])\n    .groupBy('neighborhood).count()       :TypedDataFrame[(String, Long)])\n    .as[NeighborhoodCount]()              :TypedDataFrame[NeighborhoodCount])\n    .sortDesc('count)                     :TypedDataFrame[NeighborhoodCount])\n    .select('neighborhood)                :TypedDataFrame[Tuple1[String]])\n    .head._1\n}\n\nIf you compare this version to vanilla Spark where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.\nLimitations\nThe main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.\nIn the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in Frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.\n"}}}
\ No newline at end of file

From 754d93e740bd0eea7260d74e98cd980efdc9329f Mon Sep 17 00:00:00 2001
From: imarios 
Date: Tue, 19 Jan 2021 20:38:03 -0800
Subject: [PATCH 005/220] Rebuild documentation (df67b00)

---
 Cats.html                                     |  30 +-
 FeatureOverview.html                          | 322 ++++++--
 Injection.html                                |  14 +-
 Job.html                                      |   8 +-
 TypedDataFrame.html                           |   6 +-
 TypedDatasetVsSparkDataset.html               | 259 ++++---
 TypedEncoder.html                             |  38 +-
 TypedML.html                                  |  30 +-
 .../gitbook/fonts/fontawesome/FontAwesome.otf | Bin 0 -> 124988 bytes
 .../fonts/fontawesome/fontawesome-webfont.eot | Bin 0 -> 76518 bytes
 .../fonts/fontawesome/fontawesome-webfont.svg | 685 ++++++++++++++++++
 .../fonts/fontawesome/fontawesome-webfont.ttf | Bin 0 -> 152796 bytes
 .../fontawesome/fontawesome-webfont.woff      | Bin 0 -> 90412 bytes
 .../fontawesome/fontawesome-webfont.woff2     | Bin 0 -> 71896 bytes
 .../fontsettings.js                           | 240 ++++++
 .../gitbook-plugin-fontsettings/website.css   | 291 ++++++++
 .../gitbook-plugin-highlight/ebook.css        | 135 ++++
 .../gitbook-plugin-highlight/website.css      | 434 +++++++++++
 .../gitbook/gitbook-plugin-lunr/lunr.min.js   |   7 +
 .../gitbook-plugin-lunr/search-lunr.js        |  59 ++
 .../gitbook/gitbook-plugin-search/lunr.min.js |   7 +
 .../gitbook-plugin-search/search-engine.js    |  50 ++
 .../gitbook/gitbook-plugin-search/search.css  |  35 +
 .../gitbook/gitbook-plugin-search/search.js   | 213 ++++++
 .../gitbook/gitbook-plugin-sharing/buttons.js |  90 +++
 docs/book/gitbook/gitbook.js                  |   4 +
 .../apple-touch-icon-precomposed-152.png      | Bin 0 -> 4817 bytes
 docs/book/gitbook/images/favicon.ico          | Bin 0 -> 4286 bytes
 docs/book/gitbook/style.css                   |   9 +
 docs/book/gitbook/theme.js                    |   4 +
 docs/src/main/tut/README.md                   |  42 +-
 index.html                                    |  84 ++-
 search_index.json                             |   2 +-
 33 files changed, 2846 insertions(+), 252 deletions(-)
 create mode 100644 docs/book/gitbook/fonts/fontawesome/FontAwesome.otf
 create mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.eot
 create mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.svg
 create mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.ttf
 create mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff
 create mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff2
 create mode 100644 docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js
 create mode 100644 docs/book/gitbook/gitbook-plugin-fontsettings/website.css
 create mode 100644 docs/book/gitbook/gitbook-plugin-highlight/ebook.css
 create mode 100644 docs/book/gitbook/gitbook-plugin-highlight/website.css
 create mode 100644 docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js
 create mode 100644 docs/book/gitbook/gitbook-plugin-lunr/search-lunr.js
 create mode 100644 docs/book/gitbook/gitbook-plugin-search/lunr.min.js
 create mode 100644 docs/book/gitbook/gitbook-plugin-search/search-engine.js
 create mode 100644 docs/book/gitbook/gitbook-plugin-search/search.css
 create mode 100644 docs/book/gitbook/gitbook-plugin-search/search.js
 create mode 100644 docs/book/gitbook/gitbook-plugin-sharing/buttons.js
 create mode 100644 docs/book/gitbook/gitbook.js
 create mode 100644 docs/book/gitbook/images/apple-touch-icon-precomposed-152.png
 create mode 100644 docs/book/gitbook/images/favicon.ico
 create mode 100644 docs/book/gitbook/style.css
 create mode 100644 docs/book/gitbook/theme.js

diff --git a/Cats.html b/Cats.html
index c720e21b5..7939062f5 100644
--- a/Cats.html
+++ b/Cats.html
@@ -295,10 +295,10 @@ 
                Effect Suspension in typed datasets
 // typedDs: frameless.TypedDataset[(Int, String)] = [_1: int, _2: string]
 
 val result: Action[(Seq[(Int, String)], Long)] = for {
-  sample <- typedDs.take(1)
-  count <- typedDs.count()
+  sample <- typedDs.take[Action](1)
+  count <- typedDs.count[Action]()
 } yield (sample, count)
-// result: Action[(Seq[(Int, String)], Long)] = Kleisli(<function1>)
+// result: Action[(Seq[(Int, String)], Long)] = Kleisli(cats.data.Kleisli$$$Lambda$12127/0x0000000802d65040@27729265)
 
                
 
                As with Job, note that nothing has been run yet. The effect has been properly suspended. To
 run our program, we must first supply the SparkSession to the ReaderT layer and then
@@ -324,7 +324,7 @@ 
                Convenie
          }
        }
 } yield r
-// resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli(<function1>)
+// resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli(cats.data.Kleisli$$$Lambda$12127/0x0000000802d65040@252f71e5)
 
 resultWithDescription.run(spark).unsafeRunSync()
 // Description: fancy cats
@@ -340,7 +340,7 @@ 
                Using algebraic typecla
 // import frameless.cats.implicits._
 
 val data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)
-// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[14] at makeRDD at <console>:44
+// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[12] at makeRDD at <console>:43
 
 println(data.csum)
 // (10,9,9)
@@ -355,7 +355,7 @@ 
                Using algebraic typecla
 elements inside the RDD. There are counterpart operations to those that have an Option return type
 to deal with the case of an empty RDD:
                
 
                val data: RDD[(Int, Int, Int)] = sc.emptyRDD
-// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = EmptyRDD[15] at emptyRDD at <console>:44
+// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = EmptyRDD[13] at emptyRDD at <console>:43
 
 println(data.csum)
 // (0,0,0)
@@ -384,10 +384,10 @@ 
                Using algebraic typecla
 
 val allData: RDD[(User,TransactionCount)] =
    sc.makeRDD(("Bob", 12) :: ("Joe", 1) :: ("Anna", 100) :: ("Bob", 20) :: ("Joe", 2) :: Nil)
-// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[16] at makeRDD at <console>:47
+// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[14] at makeRDD at <console>:46
 
 val totalPerUser =  allData.csumByKey
-// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[17] at reduceByKey at implicits.scala:42
+// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[15] at reduceByKey at implicits.scala:42
 
 totalPerUser.collectAsMap
 // res16: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)
@@ -399,10 +399,10 @@ 
                Using algebraic typecla
 val allDataComplexKeu =
    sc.makeRDD( ("Bob", SortedMap("task1" -> 10)) ::
     ("Joe", SortedMap("task1" -> 1, "task2" -> 3)) :: ("Bob", SortedMap("task1" -> 10, "task2" -> 1)) :: ("Joe", SortedMap("task3" -> 4)) :: Nil )
-// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ParallelCollectionRDD[18] at makeRDD at <console>:46
+// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ParallelCollectionRDD[16] at makeRDD at <console>:45
 
 val overalTasksPerUser = allDataComplexKeu.csumByKey
-// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ShuffledRDD[19] at reduceByKey at implicits.scala:42
+// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ShuffledRDD[17] at reduceByKey at implicits.scala:42
 
 overalTasksPerUser.collectAsMap
 // res17: scala.collection.Map[String,scala.collection.immutable.SortedMap[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))
@@ -420,13 +420,13 @@ 
                Joins
                
 // import frameless.cats.outer._
 
 val day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 2, 1 -> 4)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Sam", Map(0 -> 1)) :: Nil )
-// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[20] at makeRDD at <console>:50
+// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[18] at makeRDD at <console>:49
 
 val day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 10, 1 -> 11)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Joe", Map(0 -> 1, 1 -> 2)) :: Nil )
-// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[21] at makeRDD at <console>:50
+// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[19] at makeRDD at <console>:49
 
 val daysCombined = day1 |+| day2
-// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[25] at mapValues at implicits.scala:67
+// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[23] at mapValues at implicits.scala:67
 
 daysCombined.collect()
 // res19: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))
@@ -436,7 +436,7 @@ 
                Joins
                
 on the key and combine values using the default Semigroup for the value type.
                
 
                In cats:
                
 
                Map(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)
-// res20: Map[Int,Int] = Map(1 -> 6, 2 -> 2)
+// res20: scala.collection.immutable.Map[Int,Int] = Map(1 -> 6, 2 -> 2)
 
                
 
                                 
@@ -481,7 +481,7 @@ 
                No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"next":{"title":"Using Spark ML with TypedDataset","level":"1.8","depth":1,"path":"TypedML.md","ref":"TypedML.md","articles":[]},"previous":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Cats.md","mtime":"2018-02-18T23:18:30.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"next":{"title":"Using Spark ML with TypedDataset","level":"1.8","depth":1,"path":"TypedML.md","ref":"TypedML.md","articles":[]},"previous":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Cats.md","mtime":"2021-01-20T04:29:10.024Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2021-01-20T04:29:45.388Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/FeatureOverview.html b/FeatureOverview.html
index 7935590b2..80d86535d 100644
--- a/FeatureOverview.html
+++ b/FeatureOverview.html
@@ -300,7 +300,7 @@ 
                Creating TypedDataset instances
                
 
                Typesafe column referencing
                
 
                This is how we select a particular column from a TypedDataset:
                
 
                val cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))
-// cities: frameless.TypedDataset[String] = [_1: string]
+// cities: frameless.TypedDataset[String] = [value: string]
 
                
 
                This is completely type-safe, for instance suppose we misspell city as citi:
                
 
                aptTypedDs.select(aptTypedDs('citi))
@@ -310,43 +310,57 @@ 
                Typesafe column referencing
                
 
                
 
                This gets raised at compile time, whereas with the standard Dataset API the error appears at runtime (enjoy the stack trace):
                
 
                aptDs.select('citi)
-// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [city, surface, price, bedrooms];;
+// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [bedrooms, city, price, surface];
 // 'Project ['citi]
-// +- LocalRelation [city#53, surface#54, price#55, bedrooms#56]
+// +- LocalRelation [city#1384, surface#1385, price#1386, bedrooms#1387]
 // 
 //   at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:88)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:85)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)
-//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:70)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:288)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:279)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:289)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1$1.apply(QueryPlan.scala:293)
-//   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)
-//   at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)
-//   at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)
-//   at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)
-//   at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)
-//   at scala.collection.AbstractTraversable.map(Traversable.scala:104)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:293)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$6.apply(QueryPlan.scala:298)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:187)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:298)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:268)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:85)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)
-//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)
-//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:67)
-//   at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2884)
-//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1150)
-//   ... 430 elided
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:155)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:152)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode.$anonfun$transformUp$2(TreeNode.scala:341)
+//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:341)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$transformExpressionsUp$1(QueryPlan.scala:104)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$1(QueryPlan.scala:116)
+//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:116)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:127)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$3(QueryPlan.scala:132)
+//   at scala.collection.TraversableLike.$anonfun$map$1(TraversableLike.scala:285)
+//   at scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)
+//   at scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)
+//   at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)
+//   at scala.collection.TraversableLike.map(TraversableLike.scala:285)
+//   at scala.collection.TraversableLike.map$(TraversableLike.scala:278)
+//   at scala.collection.AbstractTraversable.map(Traversable.scala:108)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:132)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$4(QueryPlan.scala:137)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:243)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:137)
+//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:104)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1(CheckAnalysis.scala:152)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1$adapted(CheckAnalysis.scala:93)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:183)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:93)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:90)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:154)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:175)
+//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)
+//   at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)
+//   at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)
+//   at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)
+//   at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)
+//   at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)
+//   at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)
+//   at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)
+//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)
+//   at org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:90)
+//   at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)
+//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:88)
+//   at org.apache.spark.sql.Dataset.withPlan(Dataset.scala:3715)
+//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1462)
+//   ... 42 elided
 
                
 
                select() supports arbitrary column operations:
                
 
                aptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()
@@ -377,10 +391,10 @@ 
                Typesafe column referencing
                
 
                As the error suggests, we can't divide a TypedColumn of Double by Int.
 For safety, in Frameless only math operations between same types is allowed:
                
 
                val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])
-// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]
+// priceBySurfaceUnit: frameless.TypedDataset[Double] = [value: double]
 
 priceBySurfaceUnit.collect().run()
-// res6: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)
+// res4: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)
 
                
 
                Looks like it worked, but that cast seems unsafe right? Actually it is safe.
 Let's try to cast a TypedColumn of String to Double:
                
@@ -395,11 +409,62 @@ 
                Typesafe column referencing
                
 in a compilation error.
                
 
                Check here
 for the set of available CatalystCast.
                
+
                Working with Optional columns
                
+
                When working with real data we have to deal with imperfections, such as missing fields. Columns that may have
+missing data should be represented using Options. For this example, let's assume that the Apartments dataset
+may have missing values.  
                
+
                case class ApartmentOpt(city: Option[String], surface: Option[Int], price: Option[Double], bedrooms: Option[Int])
+
                
+
                val apartmentsOpt = Seq(
+  ApartmentOpt(Some("Paris"), Some(50),  Some(300000.0), None),
+  ApartmentOpt(None, None, Some(450000.0), Some(3))
+)
+
                
+
                val aptTypedDsOpt = TypedDataset.create(apartmentsOpt)
+// aptTypedDsOpt: frameless.TypedDataset[ApartmentOpt] = [city: string, surface: int ... 2 more fields]
+
+aptTypedDsOpt.show().run()
+// +-----+-------+--------+--------+
+// | city|surface|   price|bedrooms|
+// +-----+-------+--------+--------+
+// |Paris|     50|300000.0|    null|
+// | null|   null|450000.0|       3|
+// +-----+-------+--------+--------+
+//
+
                
+
                Unfortunately the syntax used above with select() will not work here:
                
+
                aptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()
+// <console>:27: error: overloaded method value * with alternatives:
+//   (u: Option[Int])(implicit n: frameless.CatalystNumeric[Option[Int]])frameless.TypedColumn[ApartmentOpt,Option[Int]] <and>
+//   [TT, W](other: frameless.TypedColumn[TT,Option[Int]])(implicit n: frameless.CatalystNumeric[Option[Int]], implicit w: frameless.With[ApartmentOpt,TT]{type Out = W}, implicit t: scala.reflect.ClassTag[Option[Int]])frameless.TypedColumn[W,Option[Int]]
+//  cannot be applied to (Int)
+//        aptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()
+//                                                     ^
+// <console>:27: error: overloaded method value + with alternatives:
+//   (u: Option[Int])(implicit n: frameless.CatalystNumeric[Option[Int]])frameless.TypedColumn[ApartmentOpt,Option[Int]] <and>
+//   [TT, W](other: frameless.TypedColumn[TT,Option[Int]])(implicit n: frameless.CatalystNumeric[Option[Int]], implicit w: frameless.With[ApartmentOpt,TT]{type Out = W})frameless.TypedColumn[W,Option[Int]]
+//  cannot be applied to (Int)
+//        aptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()
+//                                                                                   ^
+
                
+
                This is because we cannot multiple an Option with an Int. In Scala, Option has a map() method to help address
+exactly this (e.g., Some(10).map(c => c * 2)). Frameless follows a similar convention. By applying the opt method on 
+any Option[X] column you can then use map() to provide a function that works with the unwrapped type X. 
+This is best shown in the example bellow:
                
+
                scala>  aptTypedDsOpt.select(aptTypedDsOpt('surface).opt.map(c => c * 10), aptTypedDsOpt('surface).opt.map(_ + 2)).show().run()
++----+----+
+|  _1|  _2|
++----+----+
+| 500|  52|
+|null|null|
++----+----+
+
                
+
                Known issue: map() will throw a runtime exception when the applied function includes a udf(). If you want to 
+apply a udf() to an optional column, we recommend changing your udf to work directly with Optional fields. 
                
 
                Casting and projections
                
-
                With select() the resulting TypedDataset is of type TypedDataset[TupleN[...]] (with N in [1...10]).
+
                In the general case, select() returns a TypedDataset of type TypedDataset[TupleN[...]] (with N in [1...10]).
 For example, if we select three columns with types String, Int, and Boolean the result will have type
-TypedDataset[(String, Int, Boolean)]. To select more than ten columns use the selectMany() method.
-Select has better IDE support than the macro based selectMany, so prefer select() for the general case.
                
+TypedDataset[(String, Int, Boolean)]. 
                
 
                We often want to give more expressive types to the result of our computations.
 as[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long
 as the types in U and T align.
                
@@ -427,10 +492,38 @@ 
                Casting and projections
                
 //        aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]
 //                                                                  ^
 
                
+
                Advanced topics with select()
                
+
                When you select() a single column that has type A, the resulting type is TypedDataset[A] and 
+not TypedDataset[Tuple1[A]]. This behavior makes working with nested schema easier (i.e., in the case 
+where A is a complex data type) and simplifies type-checking column operations (e.g., verify that two 
+columns can be added, divided, etc.). However, when A is scalar, say a Long, it makes it harder to select 
+and work with the resulting TypedDataset[Long]. For instance, it's harder to reference this single scalar 
+column using select(). If this becomes an issue, you can bypass this behavior by using the 
+selectMany() method instead of select(). In the previous example, selectMany() will return
+TypedDataset[Tuple1[Long]] and you can reference its single column using the name _1. 
+selectMany() should also be used when you need to select more than 10 columns. 
+select() has better IDE support and compiles faster than the macro based selectMany(), 
+so prefer select() for the most common use cases.
                
+
                When you are handed a single scalar column TypedDataset (e.g., TypedDataset[Double]) 
+the best way to reference its single column is using the asCol (short for "as a column") method. 
+This is best shown in the example below. We will see more usages of asCol later in this tutorial.  
                
+
                val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])
+// priceBySurfaceUnit: frameless.TypedDataset[Double] = [value: double]
+
+priceBySurfaceUnit.select(priceBySurfaceUnit.asCol * 2).show(2).run()
+// +-------+
+// |  value|
+// +-------+
+// |12000.0|
+// | 9000.0|
+// +-------+
+// only showing top 2 rows
+//
+
                
 
                Projections
                
 
                We often want to work with a subset of the fields in a dataset.
-Projections allows to easily select the fields we are interested
-while preserving their initial name and types for extra safety.
                
+Projections allow us to easily select our fields of interest
+while preserving their initial names and types for extra safety.
                
 
                Here is an example using the TypedDataset[Apartment] with an additional column:
                
 
                val aptds = aptTypedDs // For shorter expressions
 // aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
@@ -550,7 +643,7 @@ 
                TypedDataset functions and t
 
                Drop/Replace/Add fields
                
 
                dropTupled() drops a single column and results in a tuple-based schema.
                
 
                aptTypedDs2.dropTupled('price): TypedDataset[(String,Int)]
-// res17: frameless.TypedDataset[(String, Int)] = [_1: string, _2: int]
+// res18: frameless.TypedDataset[(String, Int)] = [_1: string, _2: int]
 
                
 
                To drop a column and specify a new schema use drop().
                
 
                case class CityBeds(city: String, bedrooms: Int)
@@ -578,7 +671,7 @@ 
                Drop/Replace/Add fields
                
 // import frameless.functions.lit
 
 aptTypedDs2.withColumnReplaced('price, lit(0.001)) 
-// res19: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]
+// res20: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]
 
                
 
                Adding a column using withColumnTupled() results in a tupled-based schema.
                
 
                aptTypedDs2.withColumnTupled(lit(Array("a","b","c"))).show(2).run()
@@ -626,25 +719,22 @@ 
                Drop/Replace/Add fields
                
 // +-----+--------+---+--------+
 //
 
                
-
                A simple way to add a column without loosing important schema information is
+
                A simple way to add a column without losing important schema information is
 to project the entire source schema into a single column using the asCol() method.
                
 
                val c = cityBeds.select(cityBeds.asCol, lit(List("a","b","c")))
 // c: frameless.TypedDataset[(CityBeds, List[String])] = [_1: struct<city: string, bedrooms: int>, _2: array<string>]
 
 c.show(1).run()
-// +---------+---------+
-// |       _1|       _2|
-// +---------+---------+
-// |[Paris,2]|[a, b, c]|
-// +---------+---------+
+// +----------+---------+
+// |        _1|       _2|
+// +----------+---------+
+// |{Paris, 2}|[a, b, c]|
+// +----------+---------+
 // only showing top 1 row
 //
 
                
-
                asCol() is a new method, without a direct equivalent in Spark's Dataset or DataFrame APIs.
-When working with Spark's DataFrames, you often select all columns using .select($"*", ...). 
+
                When working with Spark's DataFrames, you often select all columns using .select($"*", ...). 
 In a way, asCol() is a typed equivalent of $"*". 
                
-
                Finally, note that using select() and asCol(), compared to using withColumn(), avoids the 
-need of an extra case class to define the result schema.
                
 
                To access nested columns, use the colMany() method. 
                
 
                c.select(c.colMany('_1, 'city), c('_2)).show(2).run()
 // +-----+---------+
@@ -704,21 +794,95 @@ 
                Working with collections
                
 //           arrayContains(t('_1), "abc")
 //                        ^
 
                
+
                Flattening columns in Spark is done with the explode() method. Unlike vanilla Spark, 
+in Frameless explode() is part of TypedDataset and not a function of a column. 
+This provides additional safety since more than one explode() applied in a single 
+statement results in runtime error in vanilla Spark.   
                
+
                val t2 = cityRatio.select(cityRatio('city), lit(List(1,2,3,4)))
+// t2: frameless.TypedDataset[(String, List[Int])] = [_1: string, _2: array<int>]
+
+val flattened = t2.explode('_2): TypedDataset[(String, Int)]
+// flattened: frameless.TypedDataset[(String, Int)] = [_1: string, _2: int]
+
+flattened.show(4).run()
+// +-----+---+
+// |   _1| _2|
+// +-----+---+
+// |Paris|  1|
+// |Paris|  2|
+// |Paris|  3|
+// |Paris|  4|
+// +-----+---+
+// only showing top 4 rows
+//
+
                
+
                Here is an example of how explode() may fail in vanilla Spark. The Frameless 
+implementation does not suffer from this problem since, by design, it can only be applied
+to a single column at a time. 
                
+
                {
+  import org.apache.spark.sql.functions.{explode => sparkExplode}
+  t2.dataset.toDF().select(sparkExplode($"_2"), sparkExplode($"_2"))
+}
+// org.apache.spark.sql.AnalysisException: Only one generator allowed per select clause but found 2: explode(_2), explode(_2)
+//   at org.apache.spark.sql.errors.QueryCompilationErrors$.moreThanOneGeneratorError(QueryCompilationErrors.scala:95)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$$anonfun$apply$22.applyOrElse(Analyzer.scala:2510)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$$anonfun$apply$22.applyOrElse(Analyzer.scala:2503)
+//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.$anonfun$resolveOperatorsUp$3(AnalysisHelper.scala:90)
+//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)
+//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.$anonfun$resolveOperatorsUp$1(AnalysisHelper.scala:90)
+//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.allowInvokingTransformsInAnalyzer(AnalysisHelper.scala:221)
+//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.resolveOperatorsUp(AnalysisHelper.scala:86)
+//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.resolveOperatorsUp$(AnalysisHelper.scala:84)
+//   at org.apache.spark.sql.catalyst.plans.logical.LogicalPlan.resolveOperatorsUp(LogicalPlan.scala:29)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$.apply(Analyzer.scala:2503)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$.apply(Analyzer.scala:2447)
+//   at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$2(RuleExecutor.scala:216)
+//   at scala.collection.LinearSeqOptimized.foldLeft(LinearSeqOptimized.scala:126)
+//   at scala.collection.LinearSeqOptimized.foldLeft$(LinearSeqOptimized.scala:122)
+//   at scala.collection.immutable.List.foldLeft(List.scala:91)
+//   at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$1(RuleExecutor.scala:213)
+//   at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$1$adapted(RuleExecutor.scala:205)
+//   at scala.collection.immutable.List.foreach(List.scala:431)
+//   at org.apache.spark.sql.catalyst.rules.RuleExecutor.execute(RuleExecutor.scala:205)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.org$apache$spark$sql$catalyst$analysis$Analyzer$$executeSameContext(Analyzer.scala:195)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.execute(Analyzer.scala:189)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.execute(Analyzer.scala:154)
+//   at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$executeAndTrack$1(RuleExecutor.scala:183)
+//   at org.apache.spark.sql.catalyst.QueryPlanningTracker$.withTracker(QueryPlanningTracker.scala:88)
+//   at org.apache.spark.sql.catalyst.rules.RuleExecutor.executeAndTrack(RuleExecutor.scala:183)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:173)
+//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)
+//   at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)
+//   at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)
+//   at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)
+//   at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)
+//   at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)
+//   at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)
+//   at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)
+//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)
+//   at org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:90)
+//   at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)
+//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:88)
+//   at org.apache.spark.sql.Dataset.withPlan(Dataset.scala:3715)
+//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1462)
+//   ... 42 elided
+
                
 
                Collecting data to the driver
                
 
                In Frameless all Spark actions (such as collect()) are safe.
                
 
                Take the first element from a dataset (if the dataset is empty return None).
                
 
                cityBeds.headOption.run()
-// res27: Option[CityBeds] = Some(CityBeds(Paris,2))
+// res30: Option[CityBeds] = Some(CityBeds(Paris,2))
 
                
 
                Take the first n elements.
                
 
                cityBeds.take(2).run()
-// res28: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3))
+// res31: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3))
 
                
 
                cityBeds.head(3).run()
-// res29: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1))
+// res32: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1))
 
                
 
                cityBeds.limit(4).collect().run()
-// res30: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1), CityBeds(Lyon,2))
+// res33: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1), CityBeds(Lyon,2))
 
                
 
                Sorting columns
                
 
                Only column types that can be sorted are allowed to be selected for sorting. 
                
@@ -726,8 +890,8 @@ 
                Sorting columns
                
 // +----+-------+--------+--------+
 // |city|surface|   price|bedrooms|
 // +----+-------+--------+--------+
-// |Lyon|     83|200000.0|       2|
 // |Lyon|     45|133000.0|       1|
+// |Lyon|     83|200000.0|       2|
 // +----+-------+--------+--------+
 // only showing top 2 rows
 //
@@ -755,7 +919,7 @@ 
                User Defined Functions
                
 // priceModifier: (String, Double) => Double = <function2>
 
 val udf = aptTypedDs.makeUDF(priceModifier)
-// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = <function2>
+// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = frameless.functions.Udf$$Lambda$12549/0x0000000803898840@61521397
 
 val aptds = aptTypedDs // For shorter expressions
 // aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
@@ -782,7 +946,7 @@ 
                GroupBy and Aggregations
                
 // priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]
 
 priceByCity.collect().run()
-// res35: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))
+// res38: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))
 
                
 
                Again if we try to aggregate a column that can't be aggregated, we get a compilation error
                
 
                aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))
@@ -859,6 +1023,20 @@ 
                Working with Optional fields
                
 // +--------+--------+
 //
 
                
+
                In addition, optional columns can be flatten using the .flattenOption method on TypedDatset.
+The result contains the rows for which the flattened column is not None (or null). The schema
+is automatically adapted to reflect this change.
                
+
                val flattenStats = bedroomStats.flattenOption('AvgPriceBeds2)
+// flattenStats: frameless.TypedDataset[this.Out] = [_1: string, _2: double ... 3 more fields]
+
+// The second Option[Double] is now of type Double, since all 'null' values are removed
+flattenStats: TypedDataset[(String, Option[Double], Double, Option[Double], Option[Double])]
+// res45: frameless.TypedDataset[(String, Option[Double], Double, Option[Double], Option[Double])] = [_1: string, _2: double ... 3 more fields]
+
                
+
                In a DataFrame, if you just ignore types, this would equivelantly be written as:
                
+
                bedroomStats.dataset.toDF().filter($"AvgPriceBeds2".isNotNull)
+// res46: org.apache.spark.sql.Dataset[org.apache.spark.sql.Row] = [city: string, AvgPriceBeds1: double ... 3 more fields]
+
                
 
                Entire TypedDataset Aggregation
                
 
                We often want to aggregate the entire TypedDataset and skip the groupBy() clause.
 In Frameless you can do this using the agg() operator directly on the TypedDataset.
@@ -916,16 +1094,16 @@ 
                Joins
                
 // withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct<city: string, surface: int ... 2 more fields>, _2: struct<name: string, population: int>]
 
 withCityInfo.show().run()
-// +--------------------+---------------+
-// |                  _1|             _2|
-// +--------------------+---------------+
-// |[Paris,50,300000....|[Paris,2229621]|
-// |[Paris,100,450000...|[Paris,2229621]|
-// |[Paris,25,250000....|[Paris,2229621]|
-// |[Lyon,83,200000.0,2]|  [Lyon,500715]|
-// |[Lyon,45,133000.0,1]|  [Lyon,500715]|
-// |[Nice,74,325000.0,3]|  [Nice,343629]|
-// +--------------------+---------------+
+// +--------------------+----------------+
+// |                  _1|              _2|
+// +--------------------+----------------+
+// |{Paris, 50, 30000...|{Paris, 2229621}|
+// |{Paris, 100, 4500...|{Paris, 2229621}|
+// |{Paris, 25, 25000...|{Paris, 2229621}|
+// |{Lyon, 83, 200000...|  {Lyon, 500715}|
+// |{Lyon, 45, 133000...|  {Lyon, 500715}|
+// |{Nice, 74, 325000...|  {Nice, 343629}|
+// +--------------------+----------------+
 //
 
                
 
                The joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].
                
@@ -991,7 +1169,7 @@ 
                No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"next":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"previous":{"title":"Introduction","level":"1.1","depth":1,"path":"README.md","ref":"README.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"FeatureOverview.md","mtime":"2018-02-18T23:18:57.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"next":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"previous":{"title":"Introduction","level":"1.1","depth":1,"path":"README.md","ref":"README.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"FeatureOverview.md","mtime":"2021-01-20T04:29:40.323Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2021-01-20T04:29:45.388Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/Injection.html b/Injection.html
index 54d695aa3..60fe243e9 100644
--- a/Injection.html
+++ b/Injection.html
@@ -265,7 +265,7 @@ 
                Example
                
 // defined class Person
 
 val people = Seq(Person(42, new java.util.Date))
-// people: Seq[Person] = List(Person(42,Sun Feb 18 15:18:58 PST 2018))
+// people: Seq[Person] = List(Person(42,Tue Jan 19 20:29:11 PST 2021))

                And an instance of a TypedDataset:

                val personDS = TypedDataset.create(people)
@@ -282,14 +282,14 @@ 
                Example
                
   def apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@37f23430
+// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@17559031

                We can be less verbose using the Injection.apply function:

                import frameless._
 // import frameless._
 
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@6cd20faa
+// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@7d716477

                Now we can create our TypedDataset:

                val personDS = TypedDataset.create(people)
@@ -334,7 +334,11 @@ 
                Another example
                
     case 2 => Female
     case 3 => Other
   })
-// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@4d1cf7ad
+// <console>:35: warning: match may not be exhaustive.
+// It would fail on the following inputs: Female, Male, Other
+//          {
+//          ^
+// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@7c0fbe02

                And now we can create our TypedDataset:

                val personDS = TypedDataset.create(people)
@@ -383,7 +387,7 @@ 
                No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"next":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"previous":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Injection.md","mtime":"2018-02-18T23:18:59.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"next":{"title":"Job[A]","level":"1.6","depth":1,"path":"Job.md","ref":"Job.md","articles":[]},"previous":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Injection.md","mtime":"2021-01-20T04:29:12.460Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2021-01-20T04:29:45.388Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/Job.html b/Job.html
index d12f5b670..2fd2ed86e 100644
--- a/Job.html
+++ b/Job.html
@@ -273,14 +273,14 @@ 
                Job[A]
                
 // import frameless.syntax._
 
 val ds = TypedDataset.create(1 to 20)
-// ds: frameless.TypedDataset[Int] = [_1: int]
+// ds: frameless.TypedDataset[Int] = [value: int]
 
 val countAndTakeJob =
   for {
     count <- ds.count()
     sample <- ds.take((count/5).toInt)
   } yield sample
-// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@729d8021
+// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@49c2901b
 
 countAndTakeJob.run()
 // res1: Seq[Int] = WrappedArray(1, 2, 3, 4)
@@ -295,7 +295,7 @@ 
                Job[A]
                
 // computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]
 
 val finalJob = computeMinOfSample(countAndTakeJob)
-// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@30c69a34
+// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@123416f3

                Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, @@ -357,7 +357,7 @@

                No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"Job[A]","level":"1.6","depth":1,"next":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"path":"Cats.md","ref":"Cats.md","articles":[]},"previous":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"path":"Injection.md","ref":"Injection.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Job.md","mtime":"2018-02-18T23:19:00.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"Job[A]","level":"1.6","depth":1,"next":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"path":"Cats.md","ref":"Cats.md","articles":[]},"previous":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"path":"Injection.md","ref":"Injection.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"Job.md","mtime":"2021-01-20T04:29:42.335Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2021-01-20T04:29:45.388Z"},"basePath":".","book":{"language":""}}); }); diff --git a/TypedDataFrame.html b/TypedDataFrame.html index ecf083efa..e889ffad4 100644 --- a/TypedDataFrame.html +++ b/TypedDataFrame.html @@ -295,7 +295,7 @@

                Type-level joins

                : TypedDataFrame[(String, Double, Int, String, Boolean)] = tf1.innerJoin(tf2).using('i) -

                Further example are available in the TypedDataFrame join tests.

                +

                Further example are available in the TypedDataFrame join tests.

                Complete example

                We now consider a complete example to see how the Frameless types can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city maps and neighborhoods:

                type Neighborhood = String
@@ -348,7 +348,7 @@ 
                Complete example
                
     .head._1
 }
                -

                If you compare this version to vanilla Spark where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.

                +

                If you compare this version to vanilla Spark where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.

                Limitations

                The main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.

                In the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in Frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.

                @@ -391,7 +391,7 @@

                No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"Proof of Concept: TypedDataFrame","level":"1.9","depth":1,"previous":{"title":"Using Spark ML with TypedDataset","level":"1.8","depth":1,"path":"TypedML.md","ref":"TypedML.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedDataFrame.md","mtime":"2018-02-18T23:19:01.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"Proof of Concept: TypedDataFrame","level":"1.9","depth":1,"previous":{"title":"Using Spark ML with TypedDataset","level":"1.8","depth":1,"path":"TypedML.md","ref":"TypedML.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedDataFrame.md","mtime":"2021-01-20T04:28:33.412Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2021-01-20T04:29:45.388Z"},"basePath":".","book":{"language":""}}); }); diff --git a/TypedDatasetVsSparkDataset.html b/TypedDatasetVsSparkDataset.html index 104096cb3..a35a2664e 100644 --- a/TypedDatasetVsSparkDataset.html +++ b/TypedDatasetVsSparkDataset.html @@ -283,9 +283,9 @@

                Comparing TypedDatasets wi // +---+---+ // | i| j| // +---+---+ -// | 1| Q| -// | 10| W| // |100| E| +// | 10| W| +// | 1| Q| // +---+---+ // @@ -310,9 +310,11 @@

                Comparing TypedDatasets wi Now, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.

                filteredDs.explain()
 // == Physical Plan ==
-// *Project [i#1771L]
-// +- *Filter (isnotnull(i#1771L) && (i#1771L = 10))
-//    +- *FileScan parquet [i#1771L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct<i:bigint>
+// *(1) Filter (isnotnull(i#23L) AND (i#23L = 10))
+// +- *(1) ColumnarToRow
+//    +- FileScan parquet [i#23L] Batched: true, DataFilters: [isnotnull(i#23L), (i#23L = 10)], Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct<i:bigint>
+// 
+//

                The last line is very important (see ReadSchema). The schema read from the parquet file only required reading column i without needing to access column j. @@ -320,43 +322,54 @@

                Comparing TypedDatasets wi

                Unfortunately, this syntax is not bulletproof: it fails at run-time if we try to access a non existing column x:

                scala> ds.filter($"i" === 10).select($"x".as[Long])
-org.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];;
+org.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];
 'Project ['x]
-+- Filter (i#1771L = cast(10 as bigint))
-   +- Relation[i#1771L,j#1772] parquet
++- Filter (i#23L = cast(10 as bigint))
+   +- Relation[i#23L,j#24] parquet
 
   at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)
-  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:88)
-  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:85)
-  at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)
-  at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)
-  at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:70)
-  at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:288)
-  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)
-  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)
-  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:279)
-  at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:289)
-  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1$1.apply(QueryPlan.scala:293)
-  at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)
-  at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)
-  at scala.collection.immutable.List.foreach(List.scala:392)
-  at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)
-  at scala.collection.immutable.List.map(List.scala:296)
-  at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:293)
-  at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$6.apply(QueryPlan.scala:298)
-  at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:187)
-  at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:298)
-  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:268)
-  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:85)
-  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)
-  at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)
-  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)
-  at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)
-  at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)
-  at org.apache.spark.sql.Dataset.<init>(Dataset.scala:165)
-  at org.apache.spark.sql.Dataset.<init>(Dataset.scala:171)
-  at org.apache.spark.sql.Dataset.select(Dataset.scala:1210)
-  ... 454 elided
+  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:155)
+  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:152)
+  at org.apache.spark.sql.catalyst.trees.TreeNode.$anonfun$transformUp$2(TreeNode.scala:341)
+  at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)
+  at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:341)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$transformExpressionsUp$1(QueryPlan.scala:104)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$1(QueryPlan.scala:116)
+  at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:116)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:127)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$3(QueryPlan.scala:132)
+  at scala.collection.TraversableLike.$anonfun$map$1(TraversableLike.scala:285)
+  at scala.collection.immutable.List.foreach(List.scala:431)
+  at scala.collection.TraversableLike.map(TraversableLike.scala:285)
+  at scala.collection.TraversableLike.map$(TraversableLike.scala:278)
+  at scala.collection.immutable.List.map(List.scala:305)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:132)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$4(QueryPlan.scala:137)
+  at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:243)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:137)
+  at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:104)
+  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1(CheckAnalysis.scala:152)
+  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1$adapted(CheckAnalysis.scala:93)
+  at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:183)
+  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:93)
+  at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:90)
+  at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:154)
+  at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:175)
+  at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)
+  at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)
+  at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)
+  at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)
+  at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)
+  at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)
+  at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)
+  at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)
+  at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)
+  at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)
+  at org.apache.spark.sql.Dataset.<init>(Dataset.scala:210)
+  at org.apache.spark.sql.Dataset.<init>(Dataset.scala:216)
+  at org.apache.spark.sql.Dataset.select(Dataset.scala:1517)
+  ... 42 elided

                There are two things to improve here. First, we would want to avoid the as[Long] casting that we are required to type for type-safety. This is clearly an area where we may introduce a bug by casting to an incompatible @@ -381,11 +394,14 @@

                Comparing TypedDatasets wi

                Unfortunately, this syntax does not allow Spark to optimize the code.

                ds.filter(_.i == 10).map(_.i).explain()
 // == Physical Plan ==
-// *SerializeFromObject [input[0, bigint, false] AS value#1805L]
-// +- *MapElements <function1>, obj#1804: bigint
-//    +- *Filter <function1>.apply
-//       +- *DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#1803: $line14.$read$$iw$$iw$$iw$$iw$Foo
-//          +- *FileScan parquet [i#1771L,j#1772] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [], ReadSchema: struct<i:bigint,j:string>
+// *(1) SerializeFromObject [input[0, bigint, false] AS value#74L]
+// +- *(1) MapElements <function1>, obj#73: bigint
+//    +- *(1) Filter <function1>.apply
+//       +- *(1) DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#72: $line14.$read$$iw$$iw$$iw$$iw$Foo
+//          +- *(1) ColumnarToRow
+//             +- FileScan parquet [i#23L,j#24] Batched: true, DataFilters: [], Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [], ReadSchema: struct<i:bigint,j:string>
+// 
+//

                As we see from the explained Physical Plan, Spark was not able to optimize our query as before. Reading the parquet file will required loading all the fields of Foo. This might be ok for @@ -405,19 +421,22 @@

                Comparing TypedDatasets wi // fds: frameless.TypedDataset[Foo] = [i: bigint, j: string] fds.filter(fds('i) === 10).select(fds('i)).show().run() -// +---+ -// | _1| -// +---+ -// | 10| -// +---+ +// +-----+ +// |value| +// +-----+ +// | 10| +// +-----+ //

                And the optimized Physical Plan:

                fds.filter(fds('i) === 10).select(fds('i)).explain()
 // == Physical Plan ==
-// *Project [i#1771L AS _1#1876L]
-// +- *Filter (isnotnull(i#1771L) && (i#1771L = 10))
-//    +- *FileScan parquet [i#1771L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct<i:bigint>
+// *(1) Project [i#23L AS value#158L]
+// +- *(1) Filter (isnotnull(i#23L) AND (i#23L = 10))
+//    +- *(1) ColumnarToRow
+//       +- FileScan parquet [i#23L] Batched: true, DataFilters: [isnotnull(i#23L), (i#23L = 10)], Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct<i:bigint>
+// 
+//

                And the compiler is our friend.

                scala> fds.filter(fds('i) === 10).select(fds('x))
@@ -433,7 +452,7 @@ 
                Differences in Encoders

                Bar is neither a case class nor a Product, so the following correctly gives a compilation error in Spark:

                scala> spark.createDataset(Seq(new Bar(1)))
-<console>:24: error: Unable to find encoder for type stored in a Dataset.  Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._  Support for serializing other types will be added in future releases.
+<console>:24: error: Unable to find encoder for type Bar. An implicit Encoder[Bar] is needed to store Bar instances in a Dataset. Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._  Support for serializing other types will be added in future releases.
        spark.createDataset(Seq(new Bar(1)))
                           ^
                @@ -446,31 +465,32 @@

                Differences in Encoders

                // java.lang.UnsupportedOperationException: No Encoder found for java.util.Date // - field (class: "java.util.Date", name: "jday") // - root class: "MyDate" -// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:632) -// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:455) -// at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:56) -// at org.apache.spark.sql.catalyst.ScalaReflection$class.cleanUpReflectionObjects(ScalaReflection.scala:809) -// at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:39) -// at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:455) -// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1$$anonfun$10.apply(ScalaReflection.scala:626) -// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1$$anonfun$10.apply(ScalaReflection.scala:614) -// at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241) -// at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241) -// at scala.collection.immutable.List.foreach(List.scala:392) -// at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241) -// at scala.collection.immutable.List.flatMap(List.scala:355) -// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:614) -// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:455) -// at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:56) -// at org.apache.spark.sql.catalyst.ScalaReflection$class.cleanUpReflectionObjects(ScalaReflection.scala:809) -// at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:39) -// at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:455) -// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:444) -// at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:71) -// at org.apache.spark.sql.Encoders$.product(Encoders.scala:275) -// at org.apache.spark.sql.LowPrioritySQLImplicits$class.newProductEncoder(SQLImplicits.scala:233) -// at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:33) -// ... 770 elided +// at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:591) +// at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73) +// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904) +// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903) +// at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49) +// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432) +// at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$6(ScalaReflection.scala:577) +// at scala.collection.immutable.List.map(List.scala:293) +// at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:562) +// at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73) +// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904) +// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903) +// at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49) +// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432) +// at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerForType$1(ScalaReflection.scala:421) +// at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73) +// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904) +// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903) +// at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49) +// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerForType(ScalaReflection.scala:413) +// at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:56) +// at org.apache.spark.sql.Encoders$.product(Encoders.scala:285) +// at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder(SQLImplicits.scala:251) +// at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder$(SQLImplicits.scala:251) +// at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:32) +// ... 42 elided

                In comparison, a TypedDataset will notify about the encoding problem at compile time: 

                TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))
@@ -486,35 +506,50 @@ 
                Aggregate vs Projected columns
                
 // import org.apache.spark.sql.functions.sum
 
                ds.select(sum($"i"), $"i"*2)
-// org.apache.spark.sql.AnalysisException: grouping expressions sequence is empty, and '`i`' is not an aggregate function. Wrap '(sum(`i`) AS `sum(i)`)' in windowing function(s) or wrap '`i`' in first() (or first_value) if you don't care which value you get.;;
-// Aggregate [sum(i#1771L) AS sum(i)#1889L, (i#1771L * cast(2 as bigint)) AS (i * 2)#1890L]
-// +- Relation[i#1771L,j#1772] parquet
+// org.apache.spark.sql.AnalysisException: grouping expressions sequence is empty, and '`i`' is not an aggregate function. Wrap '(sum(`i`) AS `sum(i)`)' in windowing function(s) or wrap '`i`' in first() (or first_value) if you don't care which value you get.;
+// Aggregate [sum(i#23L) AS sum(i)#164L, (i#23L * cast(2 as bigint)) AS (i * 2)#165L]
+// +- Relation[i#23L,j#24] parquet
 // 
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.failAnalysis(CheckAnalysis.scala:39)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer.failAnalysis(Analyzer.scala:91)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1(CheckAnalysis.scala:239)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)
-//   at scala.collection.immutable.List.foreach(List.scala:392)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1(CheckAnalysis.scala:253)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)
-//   at scala.collection.immutable.List.foreach(List.scala:392)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1(CheckAnalysis.scala:253)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$9.apply(CheckAnalysis.scala:280)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$9.apply(CheckAnalysis.scala:280)
-//   at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)
-//   at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:280)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)
-//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)
-//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:67)
-//   at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2884)
-//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1150)
-//   ... 854 elided
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.failAnalysis(CheckAnalysis.scala:50)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.failAnalysis$(CheckAnalysis.scala:49)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.failAnalysis(Analyzer.scala:154)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkValidAggregateExpression$1(CheckAnalysis.scala:263)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$12(CheckAnalysis.scala:272)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$12$adapted(CheckAnalysis.scala:272)
+//   at scala.collection.immutable.List.foreach(List.scala:431)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkValidAggregateExpression$1(CheckAnalysis.scala:272)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$12(CheckAnalysis.scala:272)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$12$adapted(CheckAnalysis.scala:272)
+//   at scala.collection.immutable.List.foreach(List.scala:431)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkValidAggregateExpression$1(CheckAnalysis.scala:272)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$15(CheckAnalysis.scala:299)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$15$adapted(CheckAnalysis.scala:299)
+//   at scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)
+//   at scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)
+//   at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1(CheckAnalysis.scala:299)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1$adapted(CheckAnalysis.scala:93)
+//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:183)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:93)
+//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:90)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:154)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:175)
+//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)
+//   at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)
+//   at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)
+//   at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)
+//   at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)
+//   at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)
+//   at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)
+//   at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)
+//   at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)
+//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)
+//   at org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:90)
+//   at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)
+//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:88)
+//   at org.apache.spark.sql.Dataset.withPlan(Dataset.scala:3715)
+//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1462)
+//   ... 42 elided

                In Frameless, mixing the two results in a compilation error.

                // To avoid confusing frameless' sum with the standard Spark's sum
@@ -531,11 +566,11 @@ 
                Aggregate vs Projected columns
                
 
                As the error suggests, we expected a TypedColumn but we got a TypedAggregate instead. 
                
 
                Here is how you apply an aggregation method in Frameless: 
                
 
                fds.agg(fsum(fds('i))+22).show().run()
-// +---+
-// | _1|
-// +---+
-// |133|
-// +---+
+// +-----+
+// |value|
+// +-----+
+// |  133|
+// +-----+
 //
 
                
 
                Similarly, mixing projections while aggregating does not make sense, and in Frameless
@@ -590,7 +625,7 @@ 
                No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"next":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"previous":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"path":"FeatureOverview.md","ref":"FeatureOverview.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedDatasetVsSparkDataset.md","mtime":"2018-02-18T23:19:06.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"next":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"path":"TypedEncoder.md","ref":"TypedEncoder.md","articles":[]},"previous":{"title":"TypedDataset: Feature Overview","level":"1.2","depth":1,"path":"FeatureOverview.md","ref":"FeatureOverview.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedDatasetVsSparkDataset.md","mtime":"2021-01-20T04:28:44.110Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2021-01-20T04:29:45.388Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/TypedEncoder.html b/TypedEncoder.html
index 0beaf6c3f..f25487898 100644
--- a/TypedEncoder.html
+++ b/TypedEncoder.html
@@ -258,10 +258,36 @@ 
                Typed Encoders in Frameless
                
 
 case class DateRange(s: java.util.Date, e: java.util.Date)
                -
                scala> val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))
-<console>:24: error: not found: value sqlContext
-       val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))
-                                    ^
+
                scala> val ds: Dataset[DateRange] = Seq(DateRange(new java.util.Date, new java.util.Date)).toDS()
+java.lang.UnsupportedOperationException: No Encoder found for java.util.Date
+- field (class: "java.util.Date", name: "s")
+- root class: "DateRange"
+  at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:591)
+  at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)
+  at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)
+  at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)
+  at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)
+  at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432)
+  at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$6(ScalaReflection.scala:577)
+  at scala.collection.immutable.List.map(List.scala:293)
+  at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:562)
+  at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)
+  at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)
+  at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)
+  at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)
+  at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432)
+  at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerForType$1(ScalaReflection.scala:421)
+  at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)
+  at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)
+  at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)
+  at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)
+  at org.apache.spark.sql.catalyst.ScalaReflection$.serializerForType(ScalaReflection.scala:413)
+  at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:56)
+  at org.apache.spark.sql.Encoders$.product(Encoders.scala:285)
+  at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder(SQLImplicits.scala:251)
+  at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder$(SQLImplicits.scala:251)
+  at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:32)
+  ... 42 elided
 
                
 
                As shown by the stack trace, this runtime error goes through ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection-based approach is its inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.
                
 
                Frameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every Frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless' type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the java.util.Date example won't compile with Frameless:
                
@@ -284,7 +310,7 @@ 
                Typed Encoders in Frameless
                
 // ds: frameless.TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>]
 
 ds.collect()
-// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@558c6c17
+// res1: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@77bca0d3

                But any non-encodable in the case class hierarchy will be detected at compile time:

                case class BarDate(d: Double, s: String, t: java.util.Date)
@@ -339,7 +365,7 @@ 
                No results matching "
         var gitbook = gitbook || [];
         gitbook.push(function() {
-            gitbook.page.hasChanged({"page":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"next":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"path":"Injection.md","ref":"Injection.md","articles":[]},"previous":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedEncoder.md","mtime":"2018-02-18T23:19:08.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}});
+            gitbook.page.hasChanged({"page":{"title":"Typed Encoders in Frameless","level":"1.4","depth":1,"next":{"title":"Injection: Creating Custom Encoders","level":"1.5","depth":1,"path":"Injection.md","ref":"Injection.md","articles":[]},"previous":{"title":"Comparing TypedDatasets with Spark's Datasets","level":"1.3","depth":1,"path":"TypedDatasetVsSparkDataset.md","ref":"TypedDatasetVsSparkDataset.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedEncoder.md","mtime":"2021-01-20T04:28:32.538Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2021-01-20T04:29:45.388Z"},"basePath":".","book":{"language":""}});
         });
     
 
diff --git a/TypedML.html b/TypedML.html
index 8db51c590..568b50247 100644
--- a/TypedML.html
+++ b/TypedML.html
@@ -293,7 +293,7 @@ 
                Training
                
 // defined class Features
 
 val assembler = TypedVectorAssembler[Features]
-// assembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@159b3f1
+// assembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@a559710
 
 case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector)
 // defined class HouseDataWithFeatures
@@ -342,10 +342,10 @@ 
                Training
                
 // defined class RFInputs
 
 val rf = TypedRandomForestRegressor[RFInputs]
-// rf: frameless.ml.regression.TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@4c620c93
+// rf: frameless.ml.regression.TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@37d61f51
 
 val model = rf.fit(trainingDataWithFeatures).run()
-// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.regression.TypedRandomForestRegressor.Outputs,org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anonfun$fit$1$$anon$1@36ed2d44
+// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.regression.TypedRandomForestRegressor.Outputs,org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@5d5c3

                TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                @@ -389,7 +389,7 @@

                Prediction

                // predictions: frameless.TypedDataset[HousePricePrediction] = [squareFeet: double, hasGarden: boolean ... 3 more fields] predictions.select(predictions.col('predictedPrice)).collect.run() -// res6: Seq[Double] = WrappedArray(420000.0) +// res6: Seq[Double] = WrappedArray(296250.0)

                model.transform(testDataWithFeatures) will only compile if testDataWithFeatures contains a field price of type Double and a field features of type Vector:

                @@ -422,7 +422,7 @@

                Training

                // defined class Features val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@66b12f1 +// vectorAssembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@eb06753 case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) // defined class HouseDataWithFeatures @@ -434,10 +434,13 @@

                Training

                // defined class StringIndexerInput val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: frameless.ml.feature.TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@666bcbec +// indexer: frameless.ml.feature.TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@4c2621e0 + +indexer.estimator.setHandleInvalid("keep") +// res8: indexer.estimator.type = strIdx_267bc5cb88b4 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: frameless.ml.AppendTransformer[StringIndexerInput,frameless.ml.feature.TypedStringIndexer.Outputs,org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anonfun$fit$1$$anon$1@5a0797e +// indexerModel: frameless.ml.AppendTransformer[StringIndexerInput,frameless.ml.feature.TypedStringIndexer.Outputs,org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@6145e82d case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -456,10 +459,10 @@

                Training

                // defined class RFInputs val rf = TypedRandomForestClassifier[RFInputs] -// rf: frameless.ml.classification.TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@be7eeed +// rf: frameless.ml.classification.TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@33ab9b32 val model = rf.fit(indexedData).run() -// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.classification.TypedRandomForestClassifier.Outputs,org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anonfun$fit$1$$anon$1@20355c2f +// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.classification.TypedRandomForestClassifier.Outputs,org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@5bd75b8e

                Prediction

                We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -498,7 +501,10 @@

                Prediction

                // defined class IndexToStringInput val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels) -// indexToString: frameless.ml.feature.TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@c97d749 +// <console>:40: warning: method labels in class StringIndexerModel is deprecated (since 3.0.0): `labels` is deprecated and will be removed in 3.1.0. Use `labelsArray` instead. +// val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels) +// ^ +// indexToString: frameless.ml.feature.TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@355dd92d case class HouseCityPrediction( features: Vector, @@ -514,7 +520,7 @@

                Prediction

                // predictions: frameless.TypedDataset[HouseCityPrediction] = [features: vector, cityIndexed: double ... 4 more fields] predictions.select(predictions.col('predictedCity)).collect.run() -// res8: Seq[String] = WrappedArray(san francisco) +// res9: Seq[String] = WrappedArray(san francisco)

                List of currently implemented TypedEstimators

                  @@ -596,7 +602,7 @@

                  No results matching " var gitbook = gitbook || []; gitbook.push(function() { - gitbook.page.hasChanged({"page":{"title":"Using Spark ML with TypedDataset","level":"1.8","depth":1,"next":{"title":"Proof of Concept: TypedDataFrame","level":"1.9","depth":1,"path":"TypedDataFrame.md","ref":"TypedDataFrame.md","articles":[]},"previous":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"path":"Cats.md","ref":"Cats.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedML.md","mtime":"2018-02-18T23:19:23.000Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2018-02-18T23:19:28.928Z"},"basePath":".","book":{"language":""}}); + gitbook.page.hasChanged({"page":{"title":"Using Spark ML with TypedDataset","level":"1.8","depth":1,"next":{"title":"Proof of Concept: TypedDataFrame","level":"1.9","depth":1,"path":"TypedDataFrame.md","ref":"TypedDataFrame.md","articles":[]},"previous":{"title":"Using Cats with RDDs","level":"1.7","depth":1,"path":"Cats.md","ref":"Cats.md","articles":[]},"dir":"ltr"},"config":{"gitbook":"*","theme":"default","variables":{},"plugins":[],"pluginsConfig":{"highlight":{},"search":{},"lunr":{"maxIndexSize":1000000,"ignoreSpecialCharacters":false},"sharing":{"facebook":true,"twitter":true,"google":false,"weibo":false,"instapaper":false,"vk":false,"all":["facebook","google","twitter","weibo","instapaper"]},"fontsettings":{"theme":"white","family":"sans","size":2},"theme-default":{"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"},"showLevel":false}},"structure":{"langs":"LANGS.md","readme":"README.md","glossary":"GLOSSARY.md","summary":"SUMMARY.md"},"pdf":{"pageNumbers":true,"fontSize":12,"fontFamily":"Arial","paperSize":"a4","chapterMark":"pagebreak","pageBreaksBefore":"/","margin":{"right":62,"left":62,"top":56,"bottom":56}},"styles":{"website":"styles/website.css","pdf":"styles/pdf.css","epub":"styles/epub.css","mobi":"styles/mobi.css","ebook":"styles/ebook.css","print":"styles/print.css"}},"file":{"path":"TypedML.md","mtime":"2021-01-20T04:29:02.680Z","type":"markdown"},"gitbook":{"version":"3.2.2","time":"2021-01-20T04:29:45.388Z"},"basePath":".","book":{"language":""}}); }); diff --git a/docs/book/gitbook/fonts/fontawesome/FontAwesome.otf b/docs/book/gitbook/fonts/fontawesome/FontAwesome.otf new file mode 100644 index 0000000000000000000000000000000000000000..d4de13e832d567ff29c5b4e9561b8c370348cc9c GIT binary patch literal 124988 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ÐT?>-5aYhU|+1c>&YMpPK5x#-mbV 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'NS^o{z1ZKlHsAybrl=JE7AP369ntV%vB zEi(fm!=g{8NmLbAS6W|murNN}LRi&xxgDs@zBGi1(M#zXCC}RO%K1FKJ}+Ng`Z1Xj zzLz5o-@`Tk33-pKR1}nFgY#-ne05|w2XzHodXG5LH=3nO5+ac&+n0nexe3wwXidnt z_0d6mOhSBglse>BI;9Ai@r!4G5NH5~M4u|WTy{FzsUf~l7{uMh{(Hgv^qQ_nO;1lv z*BEdAizUo=*O0S3NKN`|B)vX;%#k%S(Hj_ytdp5QAx#ICcpzOlQz7;+u48K|D{BDn z1B)J=<`WR$;}cL>b3UNWfqg=8}T(hny6j8{Nj+%E{dst=9U zXTjV-tbXd**&xhe??iU&zRvCNcMRPYtEgO`yLOG5O7yKuX)r!hkSpO2(8pAOErL#+ ziVZ%_WwjI@D?g&BSiL-VxrUxY;Uwt2d~}-je=(S+J%1f(aUCwpZlI2qaY{ORsIk_ly zy811(S34DKuiV8Eu8xfO*XLwFN?4Rne8j4cC~Grxt-|rxdABPFy-9%fZ-i~%r{wKD z1@eYRs++hdaV+8_pU}^!6Q}waeTPrb@;TxILq?pBHOEIB98QnmiT(XU7&$LjSLv!#syUt6&et3Nwf5IXw&&@ntWgT`^fl{|xHig@ zTkdPOWRAvRd)0m~Ue)n=9U1vT|4^a&*?HWs`5y-;!mDEU?p6PCtMNf4cfRQOvFbC5 zLmP^guTUeQYce}h`NmeJx;aey1|m=63Gg&zJVc&`YNclJROfn9i@bNUe+w4umO-H& ziJX6IrlYHmZ;tmMzmGvN)qD4^gS~xYeKk8Xo2z4akE}r@C&&S9Mowmq;W+IVcSXIg zws;R$Q5s&Q$;#5DXYwhBlMnx&-o6B^sVn{aCLs&=gd~u}k%XJXy=vXH9hb3a)lRE* zVW^{Z1CdQxBt#Ju2nd3rtU(q*5V0;*Y{hCfJJe~XGo{;9+G?kJr?sux20HczFY5ny zF1gm}*O}-4e9!lM#>3g(^PYXV=e*0)mbN`F)E|SQ_4D67hgF$ZeY0@L3-|6>{u6|s!it^3$a#~52#xFUqM46b=9e!hTVUIf=icdFmvkt}ny|{b&OVl3 zz3+a@w!-YfY}?AgV~07`q`A`yQwuejMR_@ymWTLRsm~SIHZ*6=`t!*%_0L+Hn|Bp8 z+cS90v-G?Gg1>g&)Wj2eSyS`w=Ch}BPFp*+bscN6KUc}mI{db!F|RhW%$8b_R*|+> zV4fZCUGXnXVO?Qe{ipn@%qy1m#}6jj;*&SVTl3weW!vp#o#n50T3#;t!1ban9C}p1@ph&B6WeMccTLe(WwGiDxC^1^-bK6D8UhdU41KvPazd$t3xQ> zlBg-kNSq2D(1#$JaxX~tKq>7O=JxFo8tp=Mq+ml((axPk(7(ECm!&1?@@PJ{R8t0K zudQG3PeG_VFW;8`f_;C{evhXCi_o=!RdqWWva2+^i;MRZStr&A2?vDVZWIy|=B^ML zhHFZeI|n7$_;^0#atG)HBcPxx^<_RS|HW@#<7LkrK698K^VTz;J@aWJKkMMx)-%T- z9{DT}(Gb43dAqFSwU@elH9Y65?Rx1o+|i8!kt;u6J4AIOWYw^=rL9m?0J^@}>tOQ6UZoAM&_E^+A8L zLkR5(Q(7*_N-l&cy%!Yx5OZ;Y_WezQgmy>W2!i)_zcP_19Tvl169hC>r@ zx(l)N)=>Q>T3kbqu=S2n9l8MB77%{fXSj7*SmgUyDQtm$&YNk<+QiEEcuRaiLQbMB zcIcdif+ABR{87!nSOt3j(y#aeALM=L2J#tw=gs_(2@u2(_MFZ6d*x5D7lsKc%dM81 z)6}_XS+1?=n%Mn;a2RVTAb3CTs?ZV<0E_4?{glSXAwrfJ&vDv?nO`aIa_Hxl>~9_ zfOEOMZ(;8U^ZYdr&zraA&Cb`)zWL5OXCGc*>kSkxLlN9!!9ILEpm*=9x4fOuJ})z? zxH!|6w{m6v3UIA2y~u}t*>bh@6Z;46e&2E3YBZo})<6yCBf?@k8mI$Yrpe}SviP9c zZ`clQjBkyzrf<&8+-6Vbhb(~hHu+UeMP+qWwWTp;|F&|Qr~2fHS_^c@6_?sh#xHGN zW{q6xS_^eU8Jl-+wqk{wbr1G!r9EMFPIBs+9eFu<1^L^uvNLnGXxg@=G{jkjt#kSY z2(y=$EofS4e`W*$|lP0lP!_0mu-}7 zmAPfrvN~C#?5fNwyACBox8*9iNggU6As;V~kS~`<$>Zc1@~v{Wyii^xuaP&(TjVF? z?FyA*pn_8jQjAsHriY~?Himw#kDy{`g z44578P{8tlRRQY)QUcNgwg%(}>$VCsEN~T(iCgz zG*4)bYffqYrs>jL(tI4K3JeMy9{51uoWS{k8G)sN)qyVtz8v^k;2VJ#S%%fHI@ZYk zhUM5{>}Ylo8wn{3(QF#K8Ap^-wvs)_KFL1Eo@ZZU-()Y~!scW4M`9ww$#^o8EFeos z6p1Ap$tIFZ3dk-}Mm(gQyi2ZVS*=m)&<@v*(N54ls9ma!);hHr+G6br^_eE?8&LIdsExV|9~s({&H%mg?5)QgqvOb-I(fS9Sl;eWtsn z>(=$^ZtInLtv*Em8~tGYJ^J72BlPk5B)wZ-s&CdG(jV8K*1xEKMgKSbTl!D+JqD$L zH5d&84TB8B4WkW{4bu$|80HurHmoot8*&X5h8DvSL%ZPx!(R+<87>$u8oo931S^6~ z!NY>@3!WYv9y~YrvEWs~vB8^yvx5tQcLkRR*9SKT9|}Ged@A_);Fp8{8vJH(SMbH) zkAlAp{x+Y{-U?tPpodVaTqK+K?wgo(y>= zF`w9nLRI%GQb8V5y{SE=Yun{F06pUSYGznbmbz!EcM zfVkyR-||4Nx_KLJ^apGM8F%OV|Cz($b*`R@SdS7VFG33uPWxBD0tSNhKSSA-3Wum> zD54o)19$oW0iHgUWwa_YJ3G@ppD$)R)l(rfRON%7E$}=p12q}Wlml>nYxb!uL_Lfp z<2V}`!P!X{7!IRSAfm5Xh*am~QUy6Xa!YeOd0=$u8u%?s1=B<4@&)K7CBR8|up;2& zX_AeohNEI&ycbpV@Kn({RQB*IxyHJ>Mlu8FRS&Qvk`=nfaD3NHmP}-mIg*f)l0fcd z?Iav|tEO|r%*V5M%*ErW&@qq2n`GbVzp^EKItO`D5~rh|I+fDL|u9syIBIE z|3&%RE!)fTp$ULchCae`?C5@Ruvgw=39alm>~W5Ca(!`qar^+zC;s|4r~>d5Rar%m z9_P*#umpOZBS)bP(SCzDlEFbT6e-~N1`G!A>$SIQ7)P)~Oj0OjUr~r}N61Sp zg1Q1?9>=1wZJjEz^h{I-?TkotMkG3;BkIgj8$mNXz}+wnNQ4};C!l!#M%QX61X!ec zA#c||9s(sBv~}@#Ih=d5Q<1@_5<7 z!%u>zNFr(z5~!jUK7llBtIr}UxDsM6WBZ9z8FUCJIkB4#A{}SWbPy1TL3Axq&ErTi zn)0{s2K<&Kb=i#s-=HSq#$fp)Ro?eHr{2I3^-935Wl5OQOPWY%WY@swL1);ETM`^&ofSPkp%LPv&l}>0PaS zY1yduIo7_(pKyJX)pOcMy|mocyXIz;($&Jt*cM2j%JsSVa26vdJJU8FvlhHloijNy zft|#WNe@2AH*k|4yzr&Hw~GqBBIfZNakj>kIGx1Wmsrx5*q3M_?c50zZ;&X&3=={y zVMc)Ei1?`58N6JX@Qg_9yX61YlQCF7+*857buT7f(yf$|Bc%7J+d^c!3IbWPF4!SnVJXIEg>$LMP zgWGnhU6@Iw#$CnTdNo@K3VV1FES!H#c-cxG0(HCbsu13);kR&9(r9*RPC4{KHm<|> zWSkIb>B|7ux(kn9!M60uO*I)doLQ&jxOZjj%?|x^^xo{|UA22d!_#vkAy%{g*3Wt4+(vI86>>wSi)>04joOY|jJ z$bcPK1@D&3%qQdh5&}02HXStYVc_1w&Zoqsv(U8{9{kcqgjGTbq3b0vf65L>;0WlM zn^{Z+bqP!G9%LtffA!VB6Tf;!GIz<6xtPg&(PKVvrU*I0G5lcnO^#YqS{`MOsECT4 z`rx>T;nAUoo@+h7|J^6944ixp#C+FAVBH#N;g5lzCC4|}cEi-?F_TBdwnr7z_p;>r z=bv9E)9~aRFb#QoKuAkvyMZ?W0^D!~`Z~8kjmO;iQ>oIvHa?603X5Gr3a>z+_1K;; z=Dn!?46XyiG`D77L4%b}84tN$2Xt1pcbd8_@3;6vC>paS$r8~OW^SLfQuL%{s*D_HpOnQ0=n1#tqmD|VqKU!Aol zb9a`_>uvN}LEYroRK^dspV+P319jsbOG9zP&V9DuwN0pa;FM<5do>?jv=Gcz55J#P z5YXe82z@puRHNlH==qwON+=U0RL2Qjv8EwU-(YC(8ptm~s;PL{-|ht30Ld-98 z&jhSTr3Gb$6@|SZ^c>jgZ1S{ONCV%9snf-GQC&84egW1a8FGTdc0{0O!G#gPYe7TM z=Nb4h>!TJWY4|h78D!|FA*qi+FMH0hX*>H8N=@(t+W!zLK8WIx)Bns# z%%jlilOW&;8-Q7u+KZ=P72X~m{dmgXUahUIsxAjS;Lmgyo5>gHDf4Sp5Mo zH~C}`1FPzj;p(7CSp9%ahmOWq-~%jHCa1F`rqxNnNgEDPWG0;Nc+(=Br8u95KoY(;qV91(Q1O%Xy0UY8}T!V_Op0O;{$zj8mA3@ zBF7h#!b)f=A`J!ma%+gmvuIT(JmIYfbU9~C~Ix%W;LWzt|VM#n|CUjv6Cl#D71P$cz z{RTW(kKtCL7M#p+e30>Gcv!$;anN}91sop%WPF!`@Kd?3#}i69j+1O*aX~0uFUvVH zn(8&cIi#e$wUyM?mNezmqDoJ)B&%|3O|E!S!v5re`GGTiwuL1}_E)uM90ezA?ZEn{ z+dXHjxM3NJ8>BhdFg|)5ZKkvEx)*u*hacHKoCa1UL5DAs2o`TLIG?KCz(^D+lToU@ z7>OX}sv(}rN)HhdaIC~KjbAuFfQ42nayVP*dafh)FO)BI^v5SU?UiK}rDc0GWFCvp z3o=pNlv$Iu(LyKn(x@{XPt+W0YP9_m^I;CBo5p>IfwGXrrkqooQIeB`WxON?XRR`5 z>B2c7Tt(DRP)+q-s;PdXoovb6ky`BvO|Nd*ddNzsmTCS?4oax)MEw#=#2*U<}L&?Q45jhZN1TIxVFM83n413Cx16!J@U+E1Np?(DQs zYMeR*(_`G-KP)2ZG?rABRP3s>Pw^G=xA~uxwY9YkjTYUKcjlzH3f&k`N7Z?aEjx}_ z-+lER(gli@2@^mDG<){b0{QBzr+Lz4Bb8NEo(fMWsMnuR{*Mx=%IZe>Fw z`B`JF(&NE<>?*#%LO>=|LUvXbR~A+l)E3m|*MZb_%Ru1>p#sPwsQ~gw2plJLJkR6p z@9^At-ho$**#!G3N?AcA*%Ea^Q+{hJ*7>#!kJCw8SwP%3IlHBAJ=4 zB=H5*rWAkJ9t98SR5jLNs&%M{$9B53eBs(1n&=&?ic2h{oGzsm9Ht9wG-j%5u(a-_HlG+tCo0QJXV`TUOV3f1@!1?^!M z<|L6_ypg52@fs9;hpFT;Y)y1?LPx}MB&(3>oG0pbEJZj2fL=o#hlOC!=Token_YN7 zCX}_xMs8qbC0kfEp(iHtul}~f4mI~7LAB-a>Xaf|CfQyH%0&AckPp0fcXbt^98q#C zIaL*VEA4w5JdHICn)hEOptw3vZ~Z`3Rk3~hE;}g!r_qEWmelO4Zm8O?Y1+d>P7Tg- zuObT)_oy%+Twty1lPhY|?BrgKe;(_L3A+Il7g~vRnQKdOqCH{lAJ>e;fjsIKxT(H? z%K96R;tG~09PSJ1co~PgB2w1?%>!ymNnT;A01AAy;gC;Hc?7IRIAEFuy-x{Qp=8vI z53gcRC4C|X0LE^w%RGw?Tb#0R0W}1_x#T4O5r?CX-s^?HLBw_T&nYYqVS*bw5=K`4 zdd{zB#kNdyZFS|@^U}*x_h%9u(0l0$6M;ft#G1&YNkx;an}zv%z~?~t$vE0fCTe7g z&oFdfGgT6Z0R)WL6`=8g(2W6^2quzWP>?TXhb-}t*XvQym6yi_gBkbrMA)s$%`d@6 z^!$tvf-~bW%CARk_YPewaKdQ3)u0l%JE7aIo!n@WLDlFKO^}+T^lo<>CkoNxX!4U+lW>nYy1=ch|mtk zA=&NM*w1yDNC zmP%$K<6w^B@#i%27v|!i!Gmpsqr5t=%{$Y((7W0j=S}pccyqj^-u>P-?8+dZ>;VfX6plv`!q9Tg1nJo1Y?8Lz=R$Q$lm?2Yoqd)Iq6dfnb~Z?pF)Z-@6C?`K|b zH`8tCb|BA@-Q&B%yBBvyb#Lr;cb9iJcR$tL(fv;MXWiZ&rpM4Ts3*KClQ7qgBDK^fd-8MW7H5}P#EL}=oQr8)?e5E zOaG(3N8hdY>VMFEr2k%jO@CE?MgN`tTm3is%lfbNU+Mp;|5E>j{&W3jc+B`%|B?P5 z`VaM&^cVFX=-=1BM^205YU6+DxMlw(?*BGQ#b`0o2}7UtFui0uN51iJ#~S^N>x@F2 zhD_(88PEa=b&-z`9&-Ekt=oYz6@^qFMgKqe`sY?4Z8OCGa(>856mDjttOIavX0y^w zRR%I^DE417G~OS+icUPFk^G{Y`b8MncgG=3Cc;x_m}r>(bQA}LN0>##N5kFBLsg zFXb(zf&I8>+;^27ZnR%Gg@H=KJ7uDN(IB4MQeFzl51WPsz`hd?x4*2SP0J)2=1%y% zbZkj5v_GV_67xbiFjjB--Tko^HnA@AEh*4)6hD{(gM^ za6Pr9av_}+ew4)@20IXj;-X`K8o8SZhoO1g38Ue6@btUy@#7c66@V4v{k8;8@k(tW z)dz6lQWz}<4Hx5(uZRRYD8S7;N)5_32Ih`m$^&tLEIDxmgX(y51WSlCnLeZ9;3)d8U^y|$3^Ym-bv?X z>?pGxd58w#cG0+jo0|SStYRJf=>Z##aN>^>VWfEEH;0BJJJC>B7_pudpC3*orA1lp zrEXd_sa}8|MZ?5=+>Aqwb&lc?;oKsuSxSG$MmTi`z@~Xcel#}2%0zb|5`gyT(tjbdZ~<3 zdGAgq;r*p8l}jpzl&|`kpUaH6a4CP}7c1g;wm&~9{oOXj1^)oR1;GxxJ5F-bGQ&O0 z4=dJ>#`(h|q;mS<=Sp>f-$BD9zrW5yC3wlEW7Ut_fv^q0dk>AH;WT}}yT6Wb_m6is zGlJri=J?(DPxIir(p@VgbvU|FW$9dH+nk{K%7=MPui6|QDl zWPkF9YnXxZXums9NkuvFpapOHFaj%7{%*O^%(nXkp}nS+l1tikvrh+2TbJkxOHp z>4~W+j>%*18#_tFu{bFV4fZO46Mz4!a zj&^QvM7vzh#I>75kd#zcVoYp0vUj>1{``L~Z-UFUaoV_XG<|e`*~TWO{%YVj5begM zq{oh99%NFPjZ7v!OcR-SCV_D=4(Mo)W;Qdia6JT93bPLJ4t%tZXC^TBF=OGL#U$b9 zxGPn<=!<32kv>cP*mP)l4*kXZ?=17NciKB!g*I3>Zi4!Se(dX9pID2vTs0GG(u^3BC{5C`WZ_KQc+(Fpws=Ak)L)tuv6blL#|-$d|NaLw CDx5C> literal 0 HcmV?d00001 diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.eot b/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.eot new file mode 100644 index 0000000000000000000000000000000000000000..c7b00d2ba8896fd29de846b19f89fcf0d56ad152 GIT binary patch literal 76518 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%0DyT{kunD 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⋙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 z + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.ttf b/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.ttf new file mode 100644 index 0000000000000000000000000000000000000000..f221e50a2ef60738ba30932d834530cdfe55cb3e GIT binary patch literal 152796 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

                  =v_rA!CPE#mM^4@)}X7qf;At+v)G*FZd&; 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 ALjV8( literal 0 HcmV?d00001 diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff b/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff new file mode 100644 index 0000000000000000000000000000000000000000..6e7483cf61b490c08ed644d6ef802c69472eb247 GIT binary patch literal 90412 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%0Ded40&XED0GYFoIh+AV*?9!MR5pBW?X_8Bp zK%Pi2&3!RUu9|qRP>4Z35>46R3-HSVQAZLeK|VoiF$JlT%hYN$P{~XnOQBRrwNe$3 zDkDcHp>LA~P6d z5;fR}J~SHToEBnMNz2J6@w`HcLpUx~OvPyi9!FGCnG$S!Nu$wVjzF!}7&Oz=YOP5N zluDpAY5uI%+w?#pQ9`*)A?4JNnR$45&%afA$Ec1MfKwMKS$_D?H&7v0tL4cbzLBen zPQeDPlx3w_N%C3nIgoP-8K(mC6YFKN^$A)18?Vabue>3{1M~AAzEmi_{6Wd~e6Lb{ z-=lJU_M=wD{rH(ghD>k)+VUf((EkY5=@l&~=XksKuU9Qu4%g8d8OKWX$(xqn1@$U=vss>j z&UTv)_xlSZeOiTS27(|;QR&_oo@&VMd<8K5?=eOImlmT%QOJXL!Tyye(QT*$-F9*% z*#9f>W1tI6J=q&SNmHXo9uajhj*RR%G9Uu721J-Fd`gHhd>XKq%TqSWLrubCXE~Li zuEulHFZb%qoX$;LAPb7tM0^VbNg3I|m2gIJznp`D-#uc@4v1}tk?g+`dxJ6<5{&Qh zYvTi^EYtu<%y^QE33`A2h(BQ9Xi_#nE+b+69x^D4*yE019|CeB*x}d$R>_s<4@xkN z7@H+2h}_|_(i@#xH3X9Cf-9@uzwhR88kGgGaz-|3lv)OhVs&1NN~Lfafmx}S5nFg= z4B3lDg@=NT8WnyX0iHq$)?Kw5n%Ks$z1Rs?T9!2ys2OI9u)o%eqa1Y9p{vuBphS62 z&rrmo?HmP%+nijX33FEf_=9ds89K))0VB5sXXVN?5RU4+dVSlip`gZ?FM%}cTs!Cx zvRkeUj-}URwR1i?$S?v}mI=2=a!%Ba$>Q1tqZbt`EDit$_A~Jt4gYQ5hBp#GV%++X zFxgngVF8klmS}*7(B-s8AnZK2wdru=S6g{b{h@;ij)n{kSUPd=P(6CPeH!Ktaa;m# zSaJho0mEQsaa#LtXfZl5FF6l~QzId8ol)GaA`+8FVKkKAMxAXpQ!(P2pA`k07Dn>kT@+i0w=sV?xguZi1YNXzCXwX)?u?)Ig7tC16huq z*9bgy-7nOlPa9@2N*Z@6MxvP8h(4%$_QY>!g3sp8y`AHwjD+E2%nvfM#?A^hc^?3VDn)u zIO^gzZq!B%Mpid{x{fvKpS2stjL}E^kS{9YA#eCCGgF?_lsrvbK;A9v72mB%4z?Tw z`wki!jYa&nnf)`KLMHSH!WXuqPH%bqVHw1`!J26?rc3x_j#j8N@ET}RRi)0qsYUP={P;@WeTT2$$5#TmJpMzcE=^BL@D*utX*mw`JdXpI z*9lzM%f5r#i)iIyvPc3&hdgr3?U-zYW{UayJf-77K-7>1Zu7D4%$QRB$2;;{+Z@$% zrZ4RnV+VHI*wt%V?p?9tjyI1!`dleztu3q8yGlcm_@C~mgfG5iz8ZadyDhgs7g=)s zM}Pwh-*^}8MPI$taqpKyK=4@i52v~hZUBrjkUnepnD%MopZ;q~j?annnuL;LE=rF% zQY*m(;DOG^#sV_n>)mL^Je!X7Vah~jNI3%|yoks;{|$~ukD|w)f1VEG(0Az3CZNTO z*VosA=Hy+>>(8Udfhu_y9nR=^-I!zSc|9Y84&wk$0E^H2 z?2#`PPEa0NKDlWa2t0NeSndSpUb|=AwprRLWo=WesVR~(yt;bm@Ws`u@4jd4^;6X@ zzr3cgsI{RayQR8jXxpNyHAi4i-XGQ+`V`3jdDp_Hqk-(Dca+|8{C4!koe~TBdd-e$ zhN0@}+GwOMtFEoBF6;W0t9MM%dUKTVnsCV=F>U+Bwg)2aCb6iA2|hJ1G8pitb7q1{ z24eoASU{qs((y4P!0FSYf^S&Xj3;8wWPq>yQtcmhqb>KHXgkt&;`}!!9F7z1um-FX z6JANVdZnkIXm3B^kWiP=5>~g9O1LVia39)|d`?IJ{*T1U(i8WImlO7D(j}+azY-J( z(68L2CyM+O!6!(sBwPN0h>6ilPH+1s>PB6t`=8rRfYy`mqxVyOX=kGM-#-ajPr$^( zBy-z8LHyxAgQZ`)&g7!5Pd15eXg7TVI&#mrzDC=LJ~)r(wSVI_oQ8XRR38f!;?c+m ziX?*hIv_^wWK%OnOgEx}CJ-SUNv04`3pVkhse2xSxt_48&?zbLbIDHwc3C~V^^u=nYmeN)$BmCfd>Jj;r1?ffM!fB4#%vVHlBB781miYh7UFw z%ZFN+^sK^6wMxy&gSjn*b=d_D9?&14g%^&Yqn~eud)@(S@JNw{XRh40`|#jUKk5 z%v7;J)JtjcQPjJ{6=I}{P>Xa0YJedOBO1nBqykUReG}a_w=^xM`lk1E)ycn)Fxg9{ zPAzfrZ5~!yIv3scW^uLdy_>3Y)_kf~|I1Z-tfal5XhKmzd&#j{*T2;2Pu(@g%ElJt z%+DzpTXw7lWmOlG;(kxbT+qR2r<)9supLy&u17v26I zirx3Wk-QJhJnAkgcg$MQIo(lQ?Do5H#=Tji6%gMVuc740t{V8X@ZjY%^SJ>wv06<1 z4Wi~y060L$ze|Z`qt8I3#NiN~I-6n!$uFTObfyzQ4kZo)P*UmpEz&oOm9O|lh=Q^xg=CRdPP}| zKXY-gt}**`N3*@Ku&G_{8@vs|Z8SLN#M8aZBb!5C$CP^kt;JlN-c{_6qn8VY6o%>x z;q-wbu`@MQaj<*T$o8=BinO#PqeHVbw5~28Jc2` zfz5ela{*cvlC3tjeFT@c87!{+NQQv8PvG@&PS{9Xed!D-t#5H1gd^^{?f$)GwszOLU?6w!=+T37 z(e6QO7FIt|TQy|zbJumWO$ASUz%U;$aN^)umF=N4Dda2?qrXG)56OL+67{Gt70Iug zOG;Z?%1TYsXV0J~RJ8593cUV`Ql6c;;W4w+A8=)wjn3Q=CFo6S$-IWU%9+ej3mlB) z-r?6C%kOzEcO0BDDZ@QJdF!}Gejf;ycZ@9qlNl&^t}*J#T=yJAW6Pr1NuWbrUj8~ycl!HU7!#a-av`_Xr|#cPdbmh~FLB~uI;c;rg9N2Hr6e08up-22TjC-b>tq}QV~V;W7?d84U~8I1 zw5F6x7(vMv_cqZn4B1Z?U}A`G*%0n40gA&B_G}AOD z;FTG5Muiq&QmbsJVMI&{88-g!$kO3)jZ__%WL0V&r`htNpXaW#ITJdZpZOE);WFVRc_+GlJ64RR}1dMPurj>^Z z__6)O`#@1QynHgiL5B1PVQ>bxn3o`m5M()`y`dAk4%%~b z?ZNODg<=Z4zbHUb0!8RYSKwZB=1#N6Z7Zm>x5<)2&<8JorWYRuC8yw`ZOdbS*i%Oe z+zA}_-VPl1G4i%hI2Z_{$&Q>{yCXLTe06EU5#|YjiHtPBjiZ}J=T7k!#q#+y*kN7Eij!h>FY|J+Q_N>4@^ z{dfN>I%X8^{`=?EnE?acZ9J!DvwL3L1~>HlRDYbn;n;(Bw z6W2Qv2~fep$7L^eNGqD|OQx z5F~np#IyFs8H?7O+=u!!`8s-a*ZTEW?1ZmSL#;rEYxBTGmSmeyk4RYyB>2qxz|Knq zhb)CN2Npt4{z5ibiSKm+-)k$TCsW#I!Yqkr5F(}%zzB`B!R(|{+}*$u0o-l`br|%z zZNei=;NghIxsfNLJvW()_@Y1_ynG4ax{_TvkL2b&oMW+NGvtu7}cmm61ttBi7nksHzW9VWR1q`7Q49G7KrI$62g zysCuGrSt5ejDSTVXBVr&xHYn^ZPUhlEZw|Q=y zy1phpcI@g!AOt?NdfD2cX>lO2DkA3-RcF8jPtOqdVgJg_f{8!W%sia;7iMyL8VCmm_W_K?mxBf_tnKu3J}6*Xh#| zDw%$|Kao!KhhhBm>7FjKQ#t@d&JS=LQi((l{xKKjAZlPNRZNs`r+mv3Z3^N!1h*l< z*~2qAUPpbTbEe~TJUg+N6Jn!G_ts~gK|ekN(Y^`mad7MU31BuPaBn1t_CW|{PkF8*ZHTtMYDOSTF3r@UftO|bZy`ueV6thgGu(+j+mm03uxm`>!hW&*ZA4^>^ zc4Wmj5PnlJa_kjXJiH!$Q#k?$#*V1`2Cjb?TrrSTNLC~4g-v9Ckq|NArE_2`D)wDr{tTp4R|K)Ti0e`$!lD`AAVYz5{^1qfAJ7M!0rY>Q;LFpx*oACrV)wkhWzg1Nrj6$I@<^e(UrfTqcw!K2jwqb^p_ZkFNrVQC;v-fA{Yeiostv=Sl_(F6Eq_t z@as(wL<%7@=!11*`$DkWZ}Zy_o{-OS7Wgj$Z!1ReOn#4r>v@O39D#HK_S+j`x|29R zDJ&I`qUV^CaoF9HK&eFmFA|g)#7_4+Ef?ur;h7!87m0x*+CoeK;04OBuL5R31d<#% zOP*-(p+$ST?nGtB(4NP^+;#bPcI^Q-_~+vE&dyE zVIHpf8MwiR-@$r8Dfy@1bI(YX3f_nYq90twPo;c<>p zu+A=FY#weATV<~E4-OBlXn1M$`H}N#md|b;%>b#J1I(C~*~_cvj5xpAniZh6^rTwm z)7nYKKo;#7v2x{zktn0>8n=?!rToX7XwAD7AAm-B&h1Tq{?4E`G zadfdKJwLn{)B`95=)onS{B-Y)p7 zByg`1+=%J;7_q%K#()mEIU<7P>BLUx+PO1%el)0m2NTTA=;?RfK}!}e&8QhXN`6Tx zqV4DZ`OZ7cksbwV#^)=6TkOB%E&%ojo5WmTHlDGXsTpLJf~2Vh0!rk71>nwrL<1PX zp3#rvcp)NUEUZMpsJhnV_jOD5L%GRys|CUaGYKbDrAi1Pxb&WDZ}!9?3f!(0i(Mscce~#;8=w z8y>6Y6*9U1OiU9P3p1>t#>eYmQ<^?QmW_@_|6))Z<-piv3>mX^AW&oHOmO&2gKjJw z?XhQ1)W|*he6k=i|KL}>rS0mwd=J!hkyM9rYleoz4!A^NF%}RXL;IAi8 zcsc>zF>=w5(67P;PnC%$aMdhI#r;LVS#aTb zZ8)aMQlr*rh-F|#C1pVqBg%dP0GNP#<;ft9gay(YuPZ`2kEs_NPT_&|r!$7&t}EKE zm<<~@Y}zo4*6)=!fAPr|&GNm}1%>kJf9)G}--hX>P`5|E1*`%Iuxg8Z4^k)|LmN;r z+VGe{q1!8e1~SkFnP=pCRW};ab8^xR>q7W%k6tBj8auX0uF~%TTIrl=IhB<;d-O{A zmR-BH$dx!zBRg>L-~kya`1EV9JxvM{4LHGOM%cp~D3Pk7hEXG^Y1BMwEgqbg_=2PU z%QL}*6w&NL(Sd0LG48Yj^sfifw;(Z$=th87g%c7_^ss@k%O=vp8fQ1+|ERZquNfYT zk3!O`jYa1K={bv!k-1`R@*lh^oY1QSW0y@#CP2RgA6^i%x&=sTk=HU7*;nBm_@ykgx{=-5vsuM_>a411Pd7Sq22ZH^Kx$6fHzoP6kf^Gk~?bG#e z1W=%NOlkDL*xWQYI%7k@yv6jIk*iRh+s32A8k^f`EI!@&VX+UI19K+tt*?^MfG&G% z-o{Vcf)IcXY4S(8+r<7Z&2Qr~50N=MkXmQulpfFELBdg)Dc%ifKW6+S9HgT$J+CJz zGN7f2XB)q$f1n4)(hWe~foe8_U+i)cnkE6;5zRm9Qv5X6Ay4xMeqkgFa7tncvb z!*JiA*0uWq*j3;!4~(uinHv^uIsmUL%qh&Pk7_`7qT2N1gPylp%`J(>qMwECB*jOV z;oBjTr^{ojKp?7WnSdI`)vruL5N=Gahnuwa6_aKTF?)^9bhqM$46thY+&XK9(c}hJ z>8;V^(GF7sed4@uF;?iC+P=2o@HezkUaF94q2^PYsNK|^)G_MM)EVkKkOqkV0a3aU z^@StRJjRp3_Qs2Z4O1b9_QW_(fb;NSvyXIOPppsnF&7b;5^gflbr~lJON3c9kP#>% zEU=*aM&wiGFy|rr@R;Eg7(=qh5jGn*4*_`*l0=pe!IMaVKwa7_8^UkI5-c9~@vZB00k$C}OlA9~k`Rw4!{q3;=JMlk=xF?3bE& zyG$1xlVRb~OzARR_DJV^2bTtAEH9NxjeItg(x%vp+#=d$bvk5D`{Y=bC-YjB3^SI+ zn1Bq^YV&I{hshPRTa9+P!;~8tTx@%hQ89VI5HLH!`FMTDH=H*3< z#(bbSJ3^b&T)vpkWm>!Q{7sMFxFIK$vt$WAY`F39o6heP(pKe$^5)LX3+1jNX<*Am z9d&%V$yrV_tPB(14LBUi47##{51?~@{Nu|n1IeAm67LM9$(C*lWCNOIfI-gWD40T8 zCzW!1<`5u(`BI*fNezJ^Opz|%No!#~m#@q*te;~}Gnv#;>EzhptbjQHi)N}f4RRZG zz7lmT+nJ#%lU5Yfk6Wy_v}B~N&q;)<(-uDr%~sEztiW`14m!u13xbj6v{wim@WN&H z?3p!d&ppc)is-)!7u|f#&7~GoS5Vhb zw+LPU31X_?)Y>2fSYjxy>ve$6rsS-opT&A5vAy1H0z#(}wGLsG)ToC2n$+D80SQGpy z?6$pUcd3eIENPgC9`lFCfu?^2a}095T5GiD_+mj%rdB0Unhf@wV7wx;$yXgJsP#7) zX6%}gd=hGcV|Q)5uD}m}Pi{I_3PztkjgH8Q+lw1Y&|}wWoAZm%V_Tv3yt25txtRGL z9|_s2@B4NTQ?6>vuQ@Q?>c?DL3pJiPN&THV3s@inUQh+5QWPH!fLOp|BriaS>_)Oi2{EpZ7Zft^&uzq?oBTMzP6yY;Jl#n3C64HvId9;vdCOans9+M!Pi5-|A!sUsm%SK`9jygfi zDCy0U2z&OaJSU)az0HB=YMh$kS2F@OL`-O%$jWiKu)3lC&K)~I#k6OGBS&NccUIf* zZ1fp9f>+1o^q6WUl}y@Vy~1#Rixrmjkmoo;gZpEw=t6u*r#zW!Ff$wE&%Yyyhyms+)Q&hHIm zl~}bhAn~bZcuK7*C14dkCrLCg5?F)2ef8Dy@~zjDK|srOX}mx9XZ$s(Ec z1?EmXcwCO47E)WOgVckV8u??&V^eBB1$Su=Cpfvs6!E}x0hEKIB?Oa$=zIy1B$kf~ z$pb8$@fnw(gyI??II9-~=w>k^27dFE3}OvFQY4h;45G7p%s`3{X!-?>@M+kW<_Y;6 zK3a#FIvrH#O*RXd9QLMpN$RCe?R7(D3@UY$ z>lxJ`9-NS}O$u&q4yzl+N&~r|O@*V>1+c!U@}NPuNSl)RNL>p==hONuYucdbuSRE$b_Mh3O7o*u5&t3Favnkd^U( z_n7eQ%;3X|mSVCO(YF?Bs1P*-uf*dq{kn|0mbz73hw*|MAuze<V1%k4U%d@urUmSD>7{n!LOk`r(4m zq>e>ZvAHwKv?YVH4QBRdcriDzdXUc}JMA1j_0zIytIDLdxjWPSf%?*Fi`uMpS@nxE zeVM?s=qlq9>8$@5>2)eraG@8i*V5_EVw4F&F7y!i>j!H}ii-1-Ypr_~#ns^VN)XZWeksY4GA@CTi&tQ^l84~QOuf7-~zRJ+#PxOMU$G1+rxxIkt?tRhS@Q1?{iz-0v$X|WYhf^;HK8HV#U0yYH zei$WCTzv73&j9Tdw4b@Bz^^p)0_d8s~6AGj*4`VbioIDM>3phD?LC(>O^y&`L!GR!@1Ce@7a}dOX&6;`; zQR};)Anr&CRsTbn{`YbjgtFZ@+|xK>_3{z)Q^IZT_7xTR?$!^$`pprv0g1ex!17Qc z>StsTA4j_NbUlywm!S?$z6M2EXb>@QO*w;!drl+!?~Vk~xwQjJ}_E$7?It zP$0usGqKF8xkzT1jaTAz)OFN;5y3emU`&z?Oc)lzFf2sGbTQ0hRv{n)t8xOy)#W3E zjUlR7?!JE_J0q$aF_C`3+b<&=b(YF)^*fx|^_l5u-qyU_RUC8oe z2$5WmP$W06)thEA1xb-#)(~=WmCn{U@faZfi??>3r-l?qhVhOJ2k&o(|1pvvVh@Mi zVmF!WR+}TuYUQZ z)PGase~gG@U6ALng#LCLiFX9duH&DS`kBJh0HDq$KsSuz;JE}t^&}wfbII;LpCR4C z`lrP!Ace_(!5b2u&BDB!_{YHCozc@2%$SQlKJb<}&%E^v&90h%C`rAA=Nous@`L%S zdS{;`bpU-l7v4crcw)Qg*<8KPMwSXP!pJZS2qTLasF9^YcwUYQXjdn%!UN<})X@!x zk^p#fwN_^YkE!+IJDf&MMx9Wqw~$ySpilWB;wWYe)j=pog6GSK`m~Y&@jToI=pouq z;57@1s=~xMh=@Wh5x`D~6wu>@X3ifF2uM~bmphBRJ}~Ii?y@<}jiC}}p(4F(?5eho z2WS5Iz$3$p?ISg5U^BXK;}2Jl+4+Y#V{Vu=rnD@p)Yh?W_)>pW+nBKp#R~eNMa`oM zfYRh-HrgEKhQfL}F7c#g+Ew!L-|Twc7oFU?q2)@)@Hu0HiyrOh`f74jWM76C?7Izs zU2|U9JHcN$b^4V{cST>G(wbGC?lR|=&8gSw79L_~bC$xM%T6ma0%OfZYrq&mrcLzn z0!6*sRvr^3p#vgThe1Gu#S5NEQ0in!8<~yboFD6h^c4m;7rqRB`@YXS-k^+uh2E$R z82E_+xqDE!bsf}BnVuF5*};giDfQ-(z@V1Ih#61JrJ0EjE_iyPK~bKyWZcqyhh}#! z%aeLcnci4&W7fQVvoFH;Kl4D1T;+2>l>&P6H5%{Ws65TEw3X9#j7^hj9GNz@wEl+t z-7{AXDeQb|I+*{&;)Qn0g4Q7qE}wJHyp_hurQ=KL0`_a+#}^v|&?y0a7l=S2@A%=<(I0-uP5q6Je$1hEQ#=PIH|Ezy#(5eQ@Q9=JJ^nGwM1iC(_o zCymex>39lBC%(I40kV9OeuGm8uO_%|4dc-tNQDR(SvUmGp_hUl%kkQF2#P*6%olGF{Lu|z4B8=lx?OBVLj%axn>VLg!MZaztjIuhas6T zI2;C;Fo63>;Ut9*3F|D`Bft(u1N$SgIcA_3ARmQFkT9pEnNh--mj@RH9gd(QIX-z; zA~I}PBq1K*_|8S(rREjoW->A#SKo@HY};DIgQJ~$gJ4S6@~Hou47xcf&mZ`!jYcMFb#!h3!IyQdxZ zhTuQy!{Pey=+PrX9&hOSdmch>KhhhX_0Tt9izhT{)ZOTf_csIiJ0Y(S1BLHzMnAq2 zA~pw#3l#H1>f73J|6eX(ZPR8wkvR$W#CiDD2+ok1z|To&!ErOOniD+Q6U}MCk+ZId zSZa914GJd{3kldlB2+gXCq|s?4@f*Imt>f@Go=yrE^*mJGEyUF9#SNi&3RvzDDb@Q+*f z;qO$8{J3OSD6 zIu(tRvtaUjo}M4Php)4#EzRkzQ{z!|AhT-cp(FPKm|f7QFN`QyXGW2OXBf!yUWd(O z$-8=xYpGMIgz}S+Q%8pGAD-ckD`)GJ86S*`%~)q^a8|C-fRl4tXC$A|Nwgal?wm1X z>d^V9UQ;<~Vtfzkd2V4=2~hR>!6WORjfx8R=@bYLT+BSF)sHN6zWs9t3&!X;I5TQo2k{^g|lp5FA= zn92}Ij|2*1V1X-FqH(~{$pgvjN3m9&B-iQ8mFUfq9B>uj;nXp#MaSkjyMLyj_O{3W z_40|&AMA?PuU=j-q}F@wr3sBsyzz2{RH=tmRg6X@E&sz?Z~mb|s#de^^lC<}mX*Im zzj}^LTfOTF+kx99jVcqh0aL)?{sEp2g^@0J;#Gs*#lF|$VYD|wpB8*Bc6Fk!g#c#M z-@NL~R*=|w<|1s*wzEqJ&^I8hQ0D8-uJZ!mHH+Ett!Kc{o*Qs2y_y!8cdDzC z?iB4Km;v??m4b!~b*bhkD`Gfvy+F=5tvBm(F<+!lkwwT$;gDZK(YWlES1b+(KG>0| zIUWWv^;dVCf3xH2t2>y2 zj;rAlOUPBo0iBCf7Zp`U&Y4V~khD+w&MR(-R98pPOr!B=Ry91(U;FBTKK&qGnu(U3 z+Ya31pX?VlcQ>MUZ~PR*&~Y>b9S1S60nReiD$pH)F$fxVeZQVn>eojcV>6By6?l5ZCSD`$)|kCl5B%z zVa#D{z?jS2<~Fyv2_YbE5+LDDfIw&nxgZDmHur%^n}i%tl7^JrPMV}io22=sX$rPA z{AOk)TQ)T9x8Ls{Kd^RZXJ=<;W@p~KdGp@qZN=-qeau1T9!v`#U>;^3VV+=~XI^5? zGQVXmh&aG3wU%UKyPpmT`H6ImrN*eNh!9{XAyI}HZF2<3PlRSLP>fl8#1(S_d>MWoD2)dw0 z;&Sp9lMK2%I$rPri=hDGj>Eb=GU#UwP6H4s0rk|T0G5E1u^P{_$;Pv+BPm&nT685k zv{+}gWN>GV$?OGVa*FXaknuK`VX^AL4sAdSZr78$zq8nd=MBl79^P_C%Rk-R%-j9(O{^wvxNs^&~^@wl|5nf z=8?0jqk-%DO)M}=FY{7V3j&?3 z$MHX|qHsgj?;v|}{ZJmRH>GpvZkf!8Pmf8ZmJGeoXmlh=m0&oRZj{Nu3_jh6(||_6 zflLjUCzmEUO!%K8NuorDfWxd(qZhdJ&huazI;v$;IhmYCcR?1s1}3~Lg`oA^Ic>)% z312;Y4v?esVYDk11kgjA2B$wQ;lZjZ(C_|_Upy^k{Qv^3>NHR((CbG)`L~})(Ul>u zLuK1%x#$&i7Wgzf(H9@*fo&ZSH-!ne7+3{3RD_-dKYxn8>bwj7y(rZi?w8LtZaf2K zwO4I=>7`AXzXlHxoNr|G_7~~SMm+9rVdT{FHIc_~3`-ao%)juM{lyn}u?h5yOT6HT zmPvpKN(3`|Kl%;ISZO>Dnl3hg8IuN~o1?ERniOh*0d#yR)Pd<)YV;8bubj>P?(Cym z4=(^i-ZItqht567is5Tb& z8)Z2UY8T$M>9H7%kTTpqsE#b5=myaX4&5Qi1%?1-w*x*qk=(HHc$O@9F+(FdZxg8Z zBul^|%sjkt?YXm`@7wqJ*>jOK{NXkLzd3a18vxONufK3)&B<5V4jgEE<>Z<$74E}!KU7tLDY{{Cpm%n}D)EnHY4r$qhefuVqaaY#Oo!fDLSwA*9Z0F8loosHN zbN>7cb~|_H;i}G&zT#Q)c#)qzf#>K6T{a05|L1b(>#n;&NE1*=D2=fJ{v(@llF>#F z=nI>1CJEyM`sl`Ce%rVAcVyoG?bbBQS*?$4p|T;#K`TW)ZWLS&1q2I%YF-E3=c? z&Fsh2`UGJ0*FyAJOu`L* zt~jSffnsbhU?y959;ZO=Pe}`wI)nAYgV|Z8j2aE*$}?p)wbiUl3;G=rrhONB z6g2c>k9JN&AMjbPzmDEpx^!Q{-yInR4t0h%gZxwuZ$^gKQ83w?;U&LG1sPuM?aW^P z(5c}|d&Vpsp4lT${O5dngIHQ{OJ=r=2L@A-uQEq&&P(?e2tZ*pB}vSda-d-qtOUv} z`Ed;XrFi`9q?iafz1FffGGL3jStSg|lzZBa9&KaM(YAZ;X#;JQ`ByIIS61eO$MVAP z$8a8aEWZ+LBlnJyge{AYa;5Dr1iJlagL^z?C=73+^eA8Oo41@8KWp>)DYn@^GENn=RqU(@lDD@_yQX^DSsqH~|ijHRufEBb6q15{P451>FC1g|5G_s+%6 z2I_@?V(;UR5GQpZ5M<-B6&pvE;~a5dOQaXn$1M#+zY=w=MV0F}?a3YA0)bCr?;=S$ z8LQjuf~VgS#V6Wije-*ZciQS^d*(s{(L@DowiPi+E_St$mL%5}5l7K^#=+ z)6Fiy-HrWD>MiQ6j}&{GCa!KyJ%m|+xi|>^(>n8vyTq^;zjiNXHVuFw@X<_k?|)ot z!ye!wH_(TB3^?a&jDh5r@jtJ-=xajcp?ASIU{ZA8t#6@r)W$|}%!{2b!-wBO-@`>u03p|&%uFV}a5 zwNMQrdIuMAuuOC|JlNUEa?~e9=bzv~8UT@5h|w45IvJypV{`?2$PimcTuI?OJQvk4 zcQVKD1Wm;Af``I2|MDRy8j$|egDWwSjwRdXIv;VvX(Di$#E${1>rVZzUI|Pt-cP0( z!GJ$JhM`yI1j)>aU@$a>Ok1S;?!tK?M*o!+9#^cv(U zg;JrC8@!n+i(aQt@k&-fQ-OQ;+|+sCraiJW?+E|+_ssC+cXR_X?RmEOedpWq?3n{} z@4PIeyw^}UE=LPmBVl4n6pp}R4oVFW8l;fZ%UD6+98#;)C@48D*_n}?oZ(F7IHh33 zkq%A}SXt-sn{K=9rivxEE}UxpC>&NAvr5ZyLc4NYp^z(QS16~fG;750&m8NH-4WYA zh+#QMNZH%zD~)R`avcX!!M+n~kaBNEXd-D@Y^JtmyMth$BlIbjYq z=n!3qQ?Yv%2wW#?mqwM<8=jy2tM9bR;ll?tEp(+^V+M4I!|UpjZhn%QO+|)nnVy#h znWdvYvAKE9ofLH#2QD$B%p^DeYw5;acf4`s-KCFP(5p_PUbnX(Z_^7e@DU(=p{MK} z{51Q_wmL!a#j!=N4VqW~#fB75Ttc3bzYvqUl;SjVB;RJSrOsJmz^}EsPgSN^-;Z|e zUX*T6$16G_fPbO4*gfV0h>!4Xn8zJXW? zz?UQ$W>bb_PpKYyW}`b6Nu7p##roe$oOv1iGBj>BY74DjRG*nyzi54^4M9dCW4Y*q zdOaKu^(iKh9Gz*jT8-e#7AH8h`|!s)BjmGD1ANqIO);Uu!@EDal3Nqb%naA$ULiaj zyvA@5z7z8^J|Y!j1f4J5tGfhtUD&ibFM!lLE2qySdq()jMbP{2w{-)nh`|GYTd!1X z|7`QaAm`CeM(lB94~T937(I*oQbJNuoru#u3iOA!e6>eo*n|G87k72YQ;GYb#AdFi z&qV4i7-o1O-3YdT7+8!?EE}WcTdi*T0<>Z6gu|EqeChB6d|LkI-C!;1phC;p@uH!t zJpS59R9lju^>@FyTue^;X6 z-s9CE0BirEex!>87(xVGWPHaf#WBRLJpMJ--l%^2|F%J?1@<>reALKX+oIM-w9zodnPwGa#UC<+R!SkAW zNZsR;L9h$eH(>AC2>icp1pJZLmdun{<%Mz}o3n`C!9>VTZf>4CCU#?d*-^0P=zrKs zq#L|`)W1j$qS*gouzHf@e)LgC|LkM9UUahQv)LUZ5i~IUOj*VPXkJ*b)g+uK(MC1d4%}UgSmx zJm)W*JbB?f@O19QtV`?C*@q6zUP@K&GCV%*?-0pTq34gb^f}9xoddr%qRw9%j$ZX^9OeP(m3MO9;4(W(#gLCP;R@ zFkNJbB_Hj?HX!NI)9NbC>FCF&-$BRwFTc3AUMjoo^Q|jB97p?4V!A#VPwkYs4`a zPE0jqifk#4L&uEn=~}f1UF{Sw7bM1@vp5E~p(M7yF$A~aM5g%{ z+7S1de~U0tmmFeK(!NJoy`Wo5dS6$c)8Z}{>D7dG^p7V$eQx>o>&EQitG8H^f$F)o z=k`4MdTdlO5n@u0tFwIOp+hs5Kg*VhosVAj9H+SLevLX)GS&>!Tt8TK&w`A5p9h+> zj5Sl~X#7*G8-hio`;|QaS|2Fu?CN?b{6JX`9il!IWj%4u6uOipg`Tr#uv=sDpU$I~ zcF1I2OoVm}>p7neJ0-@Sy7bHQ>U%rnR-90_b9m4Bb=WB}{?w&^GS9+m9Gz#&sLw+) zV=_XHZtv;?L4Ws07DV79u^RDuc6SRHs}GF44?K^e_a5H-*>(k?EOZm}*hH}qZ{W4y z8)AJXiZ`xy*M?n_gr5EQ0rclR2F;$Ywj2ifN44T-J26pw=5>SNbupufC+LliNY8l) zujqsbw>DlEiWn}II)PkD7^2T7a$9DL&mZ3mb;JRi;@?JCU@)K$WGS+Ix%^r5L5#-# zlQIJLvvPSpPTUdht`b~;D~vu6Z#*kfK|BvV3Ua#IM~r+{d`std*UhW++YtGX$U}C4 zr7>hhfLY!yHh{2;v?TZiv5y}W5?Yrsh|#;LPWTKmQ^k5o^vz!H!~{0N5&LNZbRJ_y znXc|kw7nQ~wTqA3+TC062_(#!(BB=8PfP+4C%=w9f^Up*7BjJT z@r1tBk)1HIF5t}6F=vL`qm~fkDEv}=uv_dd>Vk7rXiCAq#ob#kTf6DhtFw;+?ZfVd z6{lubZ%LD9Ds1MQVwYN`$sI4)o9ip88^?!(lPil-R3AQm4*iszmTWUajc<6anLRoG z%#(Xp{AIZA4#A1B^Yn(*F191h)`8~sB&cSnC9hk3LZI& zqOavO6z0lO$FrJ-c?;rl>D9RHw&3+dh#-3~B7z6iJ*VsJpy;#9OtlgLtq{fI!4YgC z7OW67>*G*e1QX6cm5|uCtPk-}r(IZ3wt3pFy1{@Ql$0t-5)2xtw0HoYQC&JkDc7{D z`{uzJGamc~;nS+&KOV(o9a!F2wdxJ@&B5P1jHYaxzv>NG+$iJaj$DsFl)tBC-dO2` z{$^HXGHw%0HF7~(6ZRJhXm~6Wd|LPBiEoBB^Rq}M=mPrYja8Gkfc;PW{vgho`ap?c zbcwh+1}Y==;8wsZmY~D$(BWT~sZv5%--X9PeYembQT1iWPhu~vFDrF~Z?v_f?)&1~Zt~AuK4VJ%EL{cu zr)#P!iR(rS|Dg5rF=GL6L8q^VvPoFuo*cVPQbXJjDY;W^(sH_@2*jIMR(bOX!%HYP+yLlS6Qr95T|^ zJr2K*rK&FmJgc>~qVI#C2F*l=@&B2iCWyXoZ3PVI4_1Tzh?##`!k}<#q_wk^B`44t z#nr;oRk!bHCN|eN34P`Wea1Wu{Zy5r>*-9NKJI-J*PA1Jf5)#cX|?8#HnUcH>DL{Y zFZ+QyJi<9+TL1j!&d7#m_%}3JS(-QaXEv~r&Cj>DQvXKaB7s5b>61x(cdjUnxbgd8 z!uy$jS(eX5znHVY?oh$Yq*&3!i}+s6ZI}+NpuS2{DK?CbP7pDd z*F;ESw#XpyvF>q^xmpIqNH{tR1%*{(Jw4gySIeIM*tp?RP zr&3#gQn4NL~Q_T!zI)Mb}K?-nTI^P!z0wcg= zFdwW0Pk^)FGWZ%qp%Q;Sf+*&ucw%OrNV|!*Vvk!Aq+tqzA`#ON1%!YZ_%ehT2#qJU zomt|>OD!P;Z2*`t?`#%x0}i;LK?L|orm{IO||?1f@Bj!bnSK*T?ulAt&C z9A5PqZLEa=5xE75Mdal?nFNj~=nJvLy2~PpRDob3+Nik1B#|!!Z1fIA3UwNVfcQ=m zLAS#Nv;=^W97)Z{B1!Z#h?hwj9{Zow}xi}7wA|2%$)Q*`y=l29+uIK4!`1>h`!%pe{UeiMBy1=jPZrA~=Q z%?cTk3>*;S$a>$*1_%J3TMaDY*P(j5>{-i0)7!y zj(ADLS@8i8KGi6e5_}?c>y!NuG^F4aDQ0t-YHUXSkgbJT1?@{zW5l2r zz7DdTDH#EGNh;qmyuPKSZTjEVq%68+#R&ML)F6Nfkw9UiIXWWxTg%v@G0y|Y8>EtC zb&4QUq^8+amQ<%zZ&V2WMukkK83r@lsl3XoW}!S=uF+VkL1=NR-6Yixv6Qnc`i{;7yud*S*m6sa9?u)8i~0^qQtK2sGQer`RD7yC z0}fZqq{>FWTmVMB)tPEhJFF=RxinQ}L4TJu*tnEbqkWh&S=HaB;@MK4W{6FlqcEAZ zwyQ7M8e|SbYD!jGwJO=^()fa$>^XHGLuS6$n#{g0)v>Hfmz4*SP}|q{-~aXffw^;l zAWvJLF5`Igqm<>~yO5Je6aYs+xW5@&&|TW>GL4>P<@|t`S=T0Dx&IU}9d@v+u1aGq z^`-NiAcqo}pp_b+CBZ;Jo>Holm8XFbtghOVeN!Xv+z{}MQCYa( zyfW>?REY(q%anO?1AweyG&I7Q=+U}*skC4C;zak+p#397x%ti4RC1GwKWq z76M&arA+EosnRlWn?yIMwS!hDl>T`Ee?5eKKdLNUTv4)ZDkp=OvKuT4m11Q7jPoYb z-Xf=&WlgDlBcLEq<#vFfb-42+8TA~`Nne`WXGdV3U#VC*P^&J&Wv{3FLVp?HU!+`l zAL{SAhlT>M;WqUZ+c->-BtnSy;!~zq;D2h`Hg)Q@=+dd%nwqvn$Cu69dh2h_0}m*> zy#4ogPR(a?2F+hH^x2tdQzkVHbSsA+LZ=@@AAR)VhNacjj)GkB&{X>9RKBS1xLRM9 zMa|1C_JY#EBWBL;cVxV8*_2r$>ihcAwJg-yN_<25j0%p3>l?)UR;5$q%vxqP@pi)W z^yEWO4|~8E8;UU-f_Zj4$NMS#vBn~*vw{H3rz18b&zr6u&a&(v$k$1Ie!?k{Axo!!O6)e$}JN;~JFQaVq zy(mhXv~lAkF|_Bxh0fa{MGmA;wsD&>nTWe?p*$T~hxv5QUQOYroRq1zT2--Gh+K^b zcpau!U!jWd0=18?^-r$4(poina+MISn(VLT7{bR!TR}t==68yA@5fNYUwe!sV`<`J zwM?%vrF4}kCX47*1XD7&uBe!$=NU+Cgc3{9tBANb3~a6S_bNiPsb?91{r{poEMC_B z|5P4`xzYc#^1!b0Sn#N2{wF1o{&FeUf9w53j>K~}i`dJ6`qD7OT}o1qAMTiIbPKnD zy2se?y4;v_I=N7B2AwllmCCFvr7}eizO#9& zEkGOQBWa-=v7I;- z8zD|aqqqlO!|937T=6N60dYUF?L^>@BSfDFBot+64~jt2i^u~p+#FmnT&MId`H(N> z<6&&iTJ@}(&Ka*ENUWvPhM~Q0lLJ|fiEN$2kEr}$8?hwG9RmvX2_nL5`tXLu9K9AzqSxNYt_G3mdGpOZd7Z_onD{S_edFo6Ak4X~& zhOoQ*1QWZ2t`&(pC^xlc4pQ?qzv!8o`0La;t~YlQ?n$>uzc(?=dj}>QdU_Id4KnZ%Qyrxf!Mhk#rafu+E_S`h7;A>H8Ae3a)H!W+b z&ysMr2L|x0w7)l4#R3Ft*gy~LA-=1f2;PB}@iHOO1Js!R$i$V@1sLiX%u8Kc+Brat zxv7<^p2M{b!Rsui#?Rff2~OKIcP^N41pRo=%J+{*;!>S!gBO)ji5L?%~t zP*Ts~=>U(N_`PGt;*m`xSuC0x+MReZ2pu~XzY~eY#r&a43GF6&tbV3~8OyRYE}-@T9sj3sNqu zoz8BsDXUVAOmqhOi)q@LX(sR&x^-AtRZvh>!0noJ``%4^Z=W=9$&6-BU#I7qXDk`m z!Q3d83lr}I(J&jqS+@VZ8=8n$;Fr=+*`PsXG@vaY*>_H@Sytt6R4uDf?0EaB=LCmC zcp+#=$y5>cj%G-wSS~{?k8Mt)UP=m!{AXi-cijSZUv}o>JvUJ!y{`YHA6{=|Ozu~W^*QKYgJN?%UJ!QhA?0x>Tva`6i zJMlR9cZxom9W%Nt@bv7jWIvF3r!R9fI;oAIuw$xNxzx>*8ozoS(Wc!p7?_e%c>yJz->|fXHiTTb7RkSv9lTrtbt(Hkbx<@AEX_ zZ(PI>FfP(8PSFk|8N>k?0c{!FEdH2U;qTFXUN@dahcMHKpI@G=uS79R&>^aeccD!4F;yjj zm#~EY6d{brW(@5z0#EUINmK~1t~ew$Z;IiL1j*JUOYe$y{zA;ZLj~|rvq&Q7;klyI z$15$N8Xk4bJ#b*|;=Caf4$SrD!)15?ADBM|Ju>l*!^drzRbHzRG!#{WFbSbgQuVo7 zZDp}h51MS5Uq@FYnfYvC{(4|;bVlQL(`XBPZO{;P(BZ9;AClJ>Ut@4!lS*nexy;33 z*)esH)m@R+`m?Ik=fbsfYv;aNnLDeKF^pCW$b)zLYu7r8&}DCEp!ed%fqBvq{+z+O zon3v8t_L$IHXiOtpv%c!1#opSE94`1#4ym6;I2hkE`l#hfDKKK7;=)&K{YC3s{%5t zNx!x51erM|{90GBFcbD&(Nd2h^)2Z0=qL3p53L0Ez^d2u=#P&FBktJ~!ju+u{_UP~=m_zO za{7*zdi%=9*k(x4MO+ zDsRdwRDdPo;St`hAG3_oEL=TATQ{-cLU)C1_qzLJ6>v&)$mnXs7ndEFlU$ThXb#G67FJDEZyq;tgK_pq z5ti|)nTDJANOhrF9o+>!cNbO{DD*0H8U4il@hfXhN&j55*_v$!yKT!- z!6!2&Csb<7gQCxqxZvy-Gx^pKCs5!5}LD5p|ELl1;{v)Cfz066y!ALV+y#ac1nEDm$a>qB9Tm|h+H?Ob`_!{Zl^zCE)WBFL$ zdosA5_!(l}n8=UF@9xa5Dj6aYzzb$4KQXDazEqqhh6M10F(fc=zga$gNI}WsK`CjI zH>6I~HdjT9MPj&r&Y(UA{%i+!^2g&j0Wm1@Mxd^Q62cS{Xla`Ees*V*BEkL`%BSca-=T0Yd&OOi`vqKYq3H#zM>gjbVvw?af zNvxt@$Hr8c(t(JzN&tP$LWV>`!3b#wv}CB+7=ooZeU!NIRBJF1{rF&f3K6?Ch_yIN z(O*2`+B!fNR~kT;U%a$$!A{F))Aq*bjJXH?syi^Zeq*W*6RQ-{faT9Qg6biIg2nZi zK2<$tcA2bF)h2nB7e^nHg**C5uguD=d=*os+VDAbRhGY&OU)ag7;V_88=T`GAc z_6{g1BQsy-HuRRiwhIqN_%+8c$&`mQ-B@#{*vuQu0*&=32)BD(?)pE7oAn&YHDdajOtV3fB25>U^gioADxY8jKml#6x<9?^|Mz!IyAhjsRZyb+bj1T*ZlQNko_l8{Xk zPT$ut>gIc^2A7(!zjv^x?SJ#BQ2BphTs<`9WH7&2TO|6a1|nx@wt5}b6fS*^&I=(P%t(->21 zE<@e4rXj8YTCGB(mHJg0R-5N<$lv$dmsurFD$ked{zcNgue|KJzA>ZsUB7_@3Yzu$ z1{DWYET>d!l){Xmb<ZoNu_50RVuFN2F(skH~5BR9EGp7 z39Y=H>Xa}t&LVhZASh!!L5mCs_&;nTgf7|yk3HBl7}-JFS@bD929HIX@HJ>d_Ormz zgd(tw2s+6Pnv6uJlSHv(&eexwS#iXZ)N zoZT6m9e%J8T)jc3B=YKyWDK8)%V}UzW1c7nFe7mfjr8;i5Z_tlW9nrA>S&kxN};I; z)z6HDe4?7Y8c-lMKp?t`ZO~K_f^kh=gF{W#(}_fosC3}vIfXBVeyTR(pbo;}_MqDn z40_x_ZbNWbFgUE!v-sFz{Ku_dTt9rt;$xiyjxSwy{JyV_a~qB?TY4N{bbgBd`^+ux zu37W$Eoa!12)%>OqUG-%oG^C(1vmozh&B+H3Scb<*5!p{3lE_yhc|y+U(lc!ZLj}k z^I>%5&_Y=#4=mUZ?*6l(uyqIA(f^o1#CBR-gn-O4$@28h>g!4gw`$1Bj7a(R$w9eG(%56Q-1T1pg) zY=G^HwxOSa9IOIzbl{nd8=u(-@>HBEE8ny9Tn$jzY|8X8>HW{4zo(DE!E~S){N@r* zeilw5&nyf(cw^Pzma+-=yWEa&VJ2J-M+zT{-9UTsUj5fhjI6QbIx@tu1w zkO*p+;Vz&dqIqN?T0%xl_wbC0FYz%@QUD3>3bk&#L~FKRCqlkw(xyq1HUXbJvroF* zy=KFTl$7*7nR0Vh|B-k2ZZ9&MW#$U=nI%K&Z#Je zcm~&7FZy>Q3mvKnjmbgG!FLddTsx*3U96}it>5@*J&w+PwQXV;o-J^KeXapT zc>Vt(deP}E8juP0JNU?ie$lIsqt>ssZv6^`ABRGCV#j3%0a`2?;6QJHfMY2o|FrZ#TBn<1FcC2qgNq=ptVVY}zxMU+{Yp4+u!7v zZ(mrMR6PZRFYPsimN+h{z7)W->Op<1;4J{QhoV0^X2Yk8qSrP90M4?;H;R{z;oZ_= zm|E`a)46L#1vs4J0blqBz+zAUz21R;t$uHRum}p75&()|s2B}&M3IiY>Ml|POjYu@ zogLxY1Uzjylf*2+T7{Z7SEe4l?mfK7dJbKFZ{520Ko%GXvflgj1``b2 zXmyj~I7Y$&(gkZaOpruh5EkCNaYEnMABK93N}kbj#NHogS*@7^T{cdYmc`b7wn@V( z$!iDqzwih!Yn2j%QrU9IhSTv?ss*JoRk-$(4N6F=pc?!q`to&&1%m7U86O2=bE}!j zAm})N?5?@o_;Up^Wx&h@SvQ_Zv@WwAVv6Ac0qDsj_#~LHu($m1`>$6;t;f($KJ;w_ zER22(Mhph#Ltnj%?te}4+j4fsg*(1NKY{&?ikYai{q*Vf(-H=*-txUi_P`$S;60C^ z`O!Id>`Oxxj;mnZM?eugfX<+gqa!z~;i8S8a)snHd5DZFNctE5I^9vQGafgzf*>0r zVu~OcLoC(#go4E*u@OTcg0-RM@I2_T0b&;9B>@XAJI5HzPz^YCEBX=*m|w0Rc-L%& zVu>o}yJdlmLUOHdv{a)=<}Kq(HQV(jUwyW3a*eB^Ooo?F=4@-}*Q|H?)%3Jd_blhB{ktZu{-nE$)JQq1@PeuPu76v|)h zpF6ZPMUeSCkSouGf?g$Mr;Jck37vl^P5l`9?H5}}-*}3B5EOy?4sB~*aqEghuf2L`<<^z+w%*C7F5I(j zQv1%Fo$Zs>?O8Z~6_D=x9#o%xiu5F~vhzwSI=QxTR4JJD#UH`6vXT96L8oHt6D|I3 zKQOtBpQ&U9QhzrNan*|17E)?lNTP2M)Vn0Cp24dV0%S&DaLgcAm#>@n8ZbWdw@UCVNVaL1YfprmM;F%495{E> z{5?0lIly=I)v05a-nsf|?=)})Ugj^~vFi_TY-!=1S0;_R=cmmhmjPkvvAz$1=AVb7 z@9=~(1uVA)r&TR`_$l!C$Y}!$9$K`uW6hXJBL{!78_IO>_~BN0rNc+baW0 zGrejyNpIkw&sH`C{ZLq4&3z3@@Tu^LceN-N8gqsQZ?3cFRAe|!a=meM-~6FvKBo@6 zTg^wpqf1w8o_A!*ID_o_2`8JY3;87SVEfmF)$f4mGxLWGEK*vlQmS7%e*D}pcXn8% zR9Fg%>@yzg@?FE~vIQ+5bi%AzlZxb)^8j`eD>@ymPYxP)c{#ZvE0=cu+!)4+k5ft zJ>`K^jTW!=T*~HMg9kOw8x&r+sp*L=H9L2_c5a712}s zoEcu?K9@Q#ws5Y1i=fS54h?s9%iMAfkiZEOyeHr}#o$Mj-T z##o7|Z%JQ0`XF!o+S9XU+&i^jauomVt6TP-)_A2bUx77~SW@()67p+r!EhtjKxa}@Rbz(Y5 zw6x|W*o4N>mAh?oyF#uQrlmiIamn|(7IjR2!CF0LtVLZ}#~f&5LP&_Ec)FJ8fGHu& zMcN}Qa~&Xys13o?m2~T{G!gRK6g!Hx=%Q9(LbzQ|Ob=nWcTP0eqkS~g+kua2v6&L* zgkm$%x%<~xp#P#laa(bCQizJGBg8ipUKJ8aba&O+ME_Kg8@3vb0mtHL^wD=XruDiy zi{W86Zm7DReZqq|7uqLW-4JJPN|n2O55?@zEoS5YSv!m+R^~6fAljI}_@Zca9>0F! z1zD&4KWmyhZ=7A%HER3cwU-gEqq3M%f)y(hL6c&w6tmXw%(MkWJxu|aTdG}~zTf6y49i|0*?(GftW=J+W=Issa(ZkVLA#E)+4RjMm5 zVcgcv&EOHW+ls_fhZv8KqFj+9`73d2Q~UK`mz>-jM?Y}Ut&%R8Q2;VkA!_$ou^T)H z^3c1e5xol;Qk^{)^r`xXK&vLYn7jnuq2a>feUJwptiv}i>>=q^K7`-x!r%ErI!C#v z9u5^jb&FfNKNdl1iWjS!n#O<|2pegVye*gSOwDSi_NFi_TBR~sshuwX(L|M{IBD&z zS*bf|N{HK*`vd;!J5vcDBt-&qTf?axA5lGjE88jpgyG~QO>3(tZnZ*LFS-xCe^UQQshkCBg~rS~)GljbVSmr~=pBy&&&iWax4*Qma(gMFYcKnt z_?hgT;Ng-^@Z2yzPWbZ7fYuF+T@@m7YQH<+Caxv;AoWc}oWt0_4QuudYDP!izGK7K zlqBz6H|LfOsCWxZfBS7Pf>d~5?W?H0s2{IM;#eNYp%My(rtBn};>eTTq7L}v_4STy z|Mu3FH-{8AO&C!*-z|}D{}$-KMcW_6jUj!kzgmjv45#HZm@Sn0Ev4SUS>u4@z=rQm z&767aJNg}E9K-(u_dp3FXH+l~)2J}qKcoF^&=?@RMaljKjjV`k*qo+X@ca((T zaP&TjrEQyhUZ-N0Fsprj-N95=w^j}}zJ}s|t z@M!&lp-B&V?;bs6nI+F0?B|<3Q>t2B7G4ELcChW=qN!*E5RQQ=AgP;Xx-;uGscijr z^x2rJzxvha?N)HBLdx{O!C}c>2DJcS4G!FaB}_ZRRebz$bj!ydg9#`8dV(I}Xq(3?-5^m_j)8&@J1o40GCBNs)k(B=d_iXh z(G3Ve;HP?eew_m^ulTJ%iF8vez?$ zco-#mhIBK=9@~J4!Lz#zAz?s%cAQV?#qwmh8@o<>*iJC5@;_VN=NEIaygba=AQRky|X26<;AQ z8@q<~=K)R}aB2*Z%3v z{bPRr>hsrLSaiI>Ztd?wTZ2PjpawMk_D3*kTHlS6hpru3YSjS158rTSysuK-dJ%~} zg<)_vi?I`=GZG_`E=I{GV8d-Mr~{44ZBH<`Th9;emJOJ~tPo{o+Jvd`A< zxG$E;fxR2=xcDP|`g@uYZAUw~avWy)cO>Uafc|RBq*L8jZ`^4KW!v8?`dT+sPN4=GIxwYvE z^TbkxYPsMuzQ(+4{Os>KhoIS~>+)A@5}|bPF-_c=z=YIP9I(M2&)~C3C!S$M+oZ*R zkcpq8k(OgEQ4-zt5QL@FJcW}2t7<9u{luZtUR*TN5_ZfPse$@P))d9KWmJyY8h z&s?u=GNuIFb)Ia0Sxv^M`3K%TFn?4=O_@L2Q|At(7|RCXuQI4in`sYay5^Nf^hQNb zy#WD_atGyCsA3GGB{o7n8tSF+vUYfBG+GMa(;Lz7Uq?5o9+xP`He1Ma;1Rd~sdikqXAjYjoDEn+ z7xCmVt;bEpSDD(bC?b-g9D-y)wO`N**-1)edaB&A`kkA%d>)uzZ_W!_YUhy8!I_6I zI{5nS9e;l4hjaTwAoQERfC-jm2ivDwvXcx}rGC&Ly|ScIKNT=rEZG)=Ri&RlU$3%S zLwfL3pDCvNf}~VdUS=CK_~y4)@3|>;m?fNNuHFCc{zb!XKlj&%4t`;N<_q+jKP5kZ z(__0FDqW?u8Ng<1C{tyyM1a}C*Zkbe5m|>7Z)wp%*#*JUM?u_QK6+^WqRE8w9f&toeEF;`|Ji5FEec*2%+mZJb(G(lB?9&s&q5 zCYS5ofw2Lt0f5jjSCTtW*e5NyED#P34Al4%?es+Z_Um>QT)nOnopi%iz4{tml>&SO zJ+C6Y{c$%zI+D8uMzJus*30WQmw-)Up%NWpZQo@r&)7pi>&1(Epf$S^{i!9&A!66C zpr_3{I0~}b_v~p$m+=vNPs-5RT_}3sdl$Up(LL>5PYvr)^n`E^-j;YhysjmCxHk_c z<^WoMsjaSSAGTNf{L|J6CfaiTtJYZ9U7!C!6ZF=daxoPQ<1$c#X9~RzFmq3}yhSDX zu5+=O2#!Q=d9;nhaKLVseC%WmhP11ZG=qV4N+ylDI%*7?nG6`Zpdtq*ITLMkm$)&F z#zz9x6+y41noTBiDkx(IbzWtKBuAoGPRFmVF`{1zLZRZ}dp`RtW`{>kCW>Cvhp8cU zcrk7&t`8jZj)CVc59-7mq&l6k&p>r+iOy_p z+yeli&$N`9rP9IP4#qoJx>Q51!Az?Y+F^DHIl7X;G2#@X#0?^`bCVr9OS17jrS(hz5bX^GZp$6!(7z?w6m^ z_1SRZJZnD&MbKFU zR>taBqDKhu_@~yGc#u*APPS&>{{8zlf{W+^C`N_XCV?<&oy1&&zY8yV`0USTA6^uW z2f!cq?PquF-`6=6Tm;4V|HbGL=Gr852A#nVfEGMfUweH`QPG;$K^Y#eWnx$yn_1Tw z_HtLb7+27v3wjJhia?Yq@d=K41pl*x8PPA%ALfH)Xvchz4O14MIt3PWaY@sNuNdMI#*hs_5g|{3VnAF%$UqSZTbkLV&b#$$VJ5f$ z_o1hvKfH>HUzHZ~g);@UzVmK2iC#+CP^S#8Q01CHNvBLQA$m8QVTo==Z<%sc(c9R6 z;44dlEUpcI39=(oM0}_Eoq*bydk7j9MW5u2WH~RYR%VEbm7+@!GFjlc^w=?WK=byk zSDQfNm3`|`7R5e@Odp4$&#b;sZm2VqUs(MNijJH912_V{0!My;t!>eFCuTx0rM9Vl zDgd{%wLX7h*198~%xMIman2`4*3CNc{M+JW5XW|i%T~m7mVwE_{D5c^ZgTn!)JvJ8 z`$x9{fJdN4EwL#MugrM-*Gs1lvYnls?2qUq7)?}mqfM+wDYc_5@4SPy*riIPl)Eg& zOSWgxT)6#XeE57!s3R*hW=x2?92x@`MU zd?1PL*3$$eagMH9z2ZB0{=I+HQ0EyN(K5i zqd%FqH=o-79K873hBuZObXi(kdhX0klSk>Kqi%b6!*Y9-gw4n_mE)1Ww(o``cYX9K zDBd=><@AGJKK#d(qefZKvmgy7siA!glc4ujKzFyO7kb7E1kUbqtLZ+o8e;lNl@l-p z4f=?xxvw}FBCz<-LwNkyh~#>$MVNn~oX^it=37w*`Wkgu^OY&qmlwbkYpP6cPL`?j zw9sD{|BNn4k%U5$l#+ajS9$c4af3|Bg>o+2xP8^C?Z#|QUYKkeH13n5 zO0VQN6}2wz^(GRUzxo3DqSp&i;f++(aIde%^!xc(8xO`YW@;)!S3d>{dGCp7cjETM z-Cp7aR9}~%H{!|71x1BwBPb5iRRys$5muY*t{~dN1x#PF*d2wIIo@Lwno`*jVEQr3J zQwrGrdEgQ0;&qqrzIEo7-4`a_wj>4Qjs2C4uWC%YWD)e}OH)Dr;;)V1p=Odz`%4wu zm+fia_rkvIjSF_4zs?WvFzP3+mmgq)A|R-txDigHLu`=ZUQm}tRMW*PDxg5S8ftCO z9)g(VOyqCbmY5r3;2AO7W$q`SZq>lzP&9GOa>7U(N}u|G56c?@{M> zCuhw%`5oZs8SL)O6xYXd)Pv89>&tB>y)jio_xP%veKMU|RdQx}PM;KGrBc!$Smmw% z1^VOc60=25_hO}Sdw8y~{5ZNk3}LRNiP+G_r8&3-+{Ew>kF9iIV5uGlT@9xY%^y1E z@FI~lh7+xD?%{C~tRL!ZkEnY9Gf^AzgGVD1|6glY0v|<{=Id2;RrOhY zRCo1}zS389=jcw-S2}0sAO>@xW_Ta8}V>cUg4> zbrya*6iq{AO6V)hSS&tD z74g;t6@bFm5ZhdYLS>|u3-1wff>6oc$<(DYnRH#&Tju4=;AJ(96LQVn!fqjXsK7?q zteUDkJw6redHi#WkJSL2P#Y~;9O|RDc!Jq)Ni_j9PhNkbJUQLnl*g&vtWE)D2)`(m zlQ^jgDW3ypfegnLaxpg=ft^-hGCSn7DyTh|VlCJ_Y%P*-1R2Z42LW~jc|x=a0umG( z(g3cI5s>Bx+KWUY@hlLA_(Z~Sx5%3Vu+N%qrfs{=L0AOt8fx=LYLyx}-+iQMkw+^?zoa(k@kFvhoqTYn4Z(0?&TVXn$|-K_q?;{Ju1yga!h z({o2<<~#)CWc0uY@yV4t1lL!+Bst*L8`wM@g&} z%3_4IH3Q1yrC2|t{JXIGum`arF%Dncaq;C!JXc=b{L|T(xy`6c6gHAAz7?B@EyPx1o1rR@8@0qRiYB1JaCDU| zAXP$yTtib&j06(b8%29>cxajbRwDeGX8Jh;MyQB(MIj1`k z@&;<^LqjLgs?4I)tVtz&I5sOOA*`VPDF+(ysd$O#34&5UqH^oeqxT`zj$;qp1Rn(d zfsN}$Rqy;xScOl|`REdtF?lxUgE1d_QPk&i5%r?Bn?M=5B4XrC4tNnsA4Uudr^_UF zSu~<$qSro@cLCln!2luzO*UajCY&g2iB9D3^5B`6P2Vpj?jtD4(;cmXCx?G4@m$go zYeW}>q-W%VXs)>u=gcHx$})MSRbS(exA>Hv5`T@}ir+ANR+;-mn5=L0)-*>;2o2FQ z7}V$a3?`Gom!}U7_E0*z@cGw_HmKjDVz~dn zeKunMNDrI0*kP6W$mG7{mAwpq=TU&M121|Op2p)Iz9n9sFL&{t`0cq87h8eBYty^* zU~ZSMMXylkTYOz}aXfD&?FDIbsiq&Ob^`reD_zrWs~j^?51$SHPi3*P%+Rt%ID~o# z-|Q5=p38Y%QV&q#8|mTunR}0lM`p1`sKfT4{czE7D&QV*p@Pb(h+84n#F+?9yWBjb z#Lxg~o)Tz}1ZwfaF?k4!hY0Y<4Nm4p6GZs!QCO@yxNZTOLWtl+*b^Tg^!TFY9g7eR z51rHo94@afX3p%)zHuu1y4s_DO0A~S@a?San)=%^$21=NP>$TU=ExtMMo>MdBF&TJ ztXP;YnKUc4NLLZhl8*3@V>+x6hfc8y7sxeF&sFIb9t9~k%OHY<>EOiOWr$>HQ^%NUn8Wt~4| z!q%xKiX{ovioTK#K#+=qqXPG`c@1Sp%2Wiv=cK!z3o!XYidjv{+i>nw-C0V1|3A&x zx|_m1U9s5_OT=x3lauBgjT1cGix+L}%QqxOQ|1AJkI)P=`8BUdF6YPsPN1 zcF>~15oik>AQZu4kdRq<=@W4j39n}aLfwc62n`L9gv3@LxqFESn^Cvkh|^N)ASb}j z$TSW!&o5l8_l=3j>}sPD*QIqVenBgzxX!d|-$5;fN^?KCrOC4$OR6b09xhJAK8>0tHThZ%!>f^~OD{LU?Gl zu-8YVYBcn}KpFy2{;ef1V%69LsK;OkQ57vCAS)Q&IY&q+rwhtFQVb;C21vhnf)eYP z%cS5rWFXPz2u=(;xw}w4JBkA=S_IYt6d5n_X_}C>6cs=!*<784BZxXBl90%1-Fcr^ zmu?NJnyH98`)6T~f=?v^KqjO^DIBlj!E4!XLuC||@+-kf;n6?|MJ2ox0}g!xWWcO7 zzUF1Dd8XHnlfLtS02YX%0+hn{ zCX?UWV*K+4t;yqW*Z=E0xzhsFczK8~CuSJ72UE|4tAsi3LRq=HJm^o5?y3+U18FiH z@)lS1Dr^0|Vtl3_gf+LA$L9y$y~U3Q00l_kYPXtI_HFRIcrn-~{B`WOPb=+-n#eQN z1>4PjP@X>?YTa&O4>;`YWDORN&;!PM+x4t1Ak2D8OB!`2LRBCo@jxeyk+b2iH67Xm zP=)bJzy^>WDJTljTB{g`0!b4?y1f*>Et>DR2nS#TQk92N55aeNQRFTmf*G(zzuCv) zeldjuhA5uPaZ>oR`FS(wz-5!4NSS0ZCCyL<{2)*-(ch>xDA)AN1xj#io6(rL{2**n zvC1`Rp^>f#5q~?c&{U=fp`0(YfHf*+qioTMA`kASUnF9sK)?T&!r6xAUSWydIC+&l zXg_eP5lm3fzr<57_BeTkQD;|^$zOduCREk7b+=^}0_xt@wlz)aCOPhB^%oDxZnH{x30;SmHB&+(=J?}UaG zT69BhM-ux*j8p<$lG(Ox|MJY%Z5u9Zn>pD{*SGCEeG*JK;jT}Gel;}2IP$yJHWzD& zWOD5K?!IhS+wo==FL?7hug4Z%TG^X7&f>lvJpa+qqmK@KwC&riu9~#{uTMR5?%Xp| z+cdt}Er*1oa{=kT=c!-6kQw9IvlsvHROMyi)s~fO{cP|3)1(LRc8e(}`ks57E7h%B2!O7#bpivO7VDU|2L)2@-lFEqIQMi5>?c03!Ov zIaTZ`VIi~GLq*&pXLjzoAzmyqSJgdo>==k0JAf-)Wm8fnlk(Gmth1sA+!hUWjp?+E zTknwF(-^CWwwv@|?3Ka+eBD0Aswhj}^w?uJ-S9M9SY-M{c=!DeK-LneU3vcvvpC{z zpu4fJ^A&zq=-TGVW_CET2{*g=={{9`JUtMf?4&jo9j$#{gViCmw znp>`U6)rmbpaQ}6NuqP~cJF1b;aUgHM|i(c9aPEWq~3Suq{FRxQl?Y~ zl_oFzgihbdZN%kTojS^R(?!>W3Y!blUM8y1F>-t(09UVut>Z{-cbcWNoZ7*$RvkWr z?eMlwdBWSl&cL-6qsgJ>v=qC^L2_Y^EMOH*uM@uH#vsXoi&w9M0Za?W;d(d@XcQ6> zMwsNtBw`YZ3A)TV=rCOJYs$qsNy8)!n?&l!g94Y5P(;gez~)5fogbv~6bxgiH#ict zEwyU@9UbV+SmKkwXL-=hqm5m zU=(@jkI4aW_v(t9BU|V^pWR)=@^-C#!iIdcigGmNtIGWvlJtgxd3nK*mn60R3RQlS zgHoy8o5sVAys^-g=eN=KmaMASxaukznDPHg16OA^ATfy!!jKMBLA6K+>nFe6W}uX4 zam@%750MTw;c`Z&iE6xc5*^feH8G7=D+ikZHfl0JB4E1fkVkcn2x?>PK8<|^OdP=1 zC&hj77B5bV71xEL#ihmF-QAtyUVQQ5#l0-cvK05leG4tn0%a+-`1POM_uVCzyIdxD z^JbEnWahm|e)ID3e#)3pU2nOX+Eo?GtVu`}NJu%^n6+EtFyGZS6%xGtYZMzSycn0I`d(ki7 zRu}joD5aMQpwL`E*rS`{P1ftR zRcTC@`fwERcpd|-memlwK2q-J6$9-ypG#41u-aDaqt}hWk1^+H2_HTYg9|r7xYUnR z13Ct26`Urixq9gzCkAvGK)8zgBI!`3g`H;e1-0S4g9%@+d$Nb^vzt+J?x*jM73+gH zOZ4>WWx~*o^oCLyL!)4XdKB2N`B$zw`Co z$uJ!MqQ38m5S=4To93P79X=i1nb5au80&6hhCGwjKDJ&T6@d}3;7I@V8Mq@?ES4F@ zmXXjl><$^s-zTny?(tYkjEHc*kOLxyo|JVCG}{IN0EPN^szu)p!6qa_89hikFx2kJ z>(jhZvSfRYC#_*Jf#pfSX_T1)*)hewS#bQADGdo6LBfwloQg6^@={{rj%t}b1j!Hz zaemC^xvPvU|Mv(84qha*y)7+OW*$(J{)Jga5HX%xJYb95|FxgHI~@-ow+Q7Do8Gns zce;2@+q|mO5qs#1U}d+s?YBsi5wBU0IHeMp1BZ-P9jD+Jw%v@`N3VwdKwUqt=iqUp zwaN3|u=CDRNtQkP#lC?O91nlAV?_v(vT*aP;&g9J|{InT1#P=RzTUB)>xGI%V zV16t3Dq~U;mu*YSK&cetb)J$Wo>APORFl$Ot*+=$wU=gSqq5(nQz z?-R!|zlXBw9QUhBrX;Y9^qf~HGJAiqjeOqQJT{K2lfaTpoY&zuUn`$trf#I-^B#kL z{==WMPdg0t_#f$J=6nY0wa0$p0vV(2mOP&=lEUdub?6S{<htOIf;zd&YORK z2&xk}o3%T^I#%PMxXT;oT6W(#Gx~rRUiPK3l6!rg36y{HW4C&u9DSTAKSC<5sX ztwZXC1;S~vVWERQWk0)3>F$;y*Q zLknEDv9z_cw6r?5<;SB+Jm|iefKJb#q32arTv}c{Jv~v2QLnuPNs}rHtygjoVB0C3U|wE22JAHTeja){kim1M>DM(~Yi_ zKL+T#LKn7oOy4!mRMLR6W7g4d7y=IYOYZla`ewZ)ebDZRBSYEcH9T2 zK>Q^V1M+ndO8oVafoa_q5ZU~hv2}MXyzbTOeA&0aAp4E~M_aN;>V)Wl?50Qk%fD}y zY*S2B_nm7VSbqG-A@6Ku>g5|TQ=K_r&Zke>s9&E|3I7OrS+xE@yP*%0%r~12;^_F% zUTvH^=*#vq)vt3m>C#FdzzR_oGLno^Jdr3Mmz>r+s6i>EAv-bcYX=u_Jx$Q}M0a!+ zz&#xik~Ja5m&y4W+eeO%_9%1s8X2A14Bq$(zZR4h)J@vLN9Pswka9qNgzwE~;4v|& zSQ55O$uxeAvAnna+IlNAaeb=+BBx*7CG~DZiUQ~_hW0i(Gqk{+(hynEq_x30!}Qpk*P>7d*2-+t^LB**(WSQiExFho?Mn@m}v& z_27et9|?BDitalyaCp2{BDd^giGrR|vp^O)@!>>iw5dr0I!8*)b&!kxlUS|aXIXcu z;BGsR&Z^`(SL>exSpB`x_XZt0UoD}CsqsA;!W*el(FIyCVPqs&t8%Fa9`5l)ckw(%G)dRlok~Z7>NJeeDU-q?GAYH zV0f02{WQPbGzF>LVJU(DOxoU=-WClouJjHJz+FP;{`q%*Zir!ez>AU7(@9(=3Z~eu zPBTN?@zJ#PK2)hbzPFP;-u?V~ zyv(qEBB)ckOt+1rDfo---e=ux4;+X~X0!fR-J*PnC@8ylwX$Z@OTBtp?xpijphTZ= z&Lyo+Gz!r|bxfD0Vjc>nHew>0S%un@e({Toq_)b_*s9YHtfHaj9}l>`XGzj+0hF5+ zRhs)^OpPxxjL8luAK{UKQ^*{A*xG_!THto8G4X&RCR zCUjdBbL3yb;!57tQrDvUq&C7guf5= z;veh)8E?PQ0m&|g(Ccr_9P3ya|9EE>3ATbOeJnz6$rb=+w}b7Bfe>zaN!Pp?pcNIU4YQ^sa#Z?a|F*YTPNh zSeWcROwNh)F}an8i9M}kw9V)EY z!yaQFjgCk7eWgcu>1>)te;r}oXlb8QY-;h>Sj^oB`2bT-2>U^7vqt-+sa6OEC ziLRq5Ccu`v=ObQS(Sto(mKr+=eG)y}Id!SO5GzXM>U&F;8NzS`0*7y!p-Lm}mFkop+Alx&kwMLQ3`V4ltAiCiRjTcK)OjSKMsD{o@U#O~Qs4{#`8D645sk(osc#4M9<)-BjJvAtEt3cVhp!o58Qq7lnp zQ0TrE9MjmR=Zie;Tg2_cL4o7bV&<7K!{m{Gs#zxFizJ?uuS4I(r8Mm^!_s0S#QIYz zt{m@25zl2KY{o^?9@#C6#%|(&faD(26K?XwHH*2<@xn_5DxIV%zd!Fcw#PP}hDujz z+q2VI&skAH+ULDQ!e+%^3W_S)Gn}5c4rfI?qmzzEQz%eG8pek42jyz>&B(HsgyKmV zv1KdosLgv*pQ}}r{zMujS_s@_fLMlrw)(9c4f#0N8Ae0kW%%S*&H@Tw<5}J?wNxVH z*4u3&EWQ@fVu<{L#$jI~wYxoI7u1ex$K;n4?PYH%;dS=f%(eS|NBm>2hdRyI>Q_jA3*Tb_g3XyGGn56bl1Ci7L0zu0uA=fi0V>qPr|S? z8%f#OnuMR>{5A6@gzF_$?jrnatKLXSt@P&zuV<;eZK8SKBe3Y3qfLFs?ASM{_h}vu z%7=({-7EB@yG)Mf-Nd%52P8dvhCDhVB?9V#@~%VfrT2$J&znh0wyrAadHT3an&>(dK*6$Tc2@R}FB%g0si<6OV!mNNccs81>lCn}hPL3>mbbRFT+ybS34WoJ zl#GD!wIIQg0D8i>f~md(_k)r$p{1YuD%Ul?pf^_ zX6~E0z^wjK8m;exNay1r@Y&~9MxT-P5kW)#k2L73LJ*;F*|`*#`=o?|<$ncUgDTHx ztEVM#A_7}1w{2*7I_BTu9MqPn{-pBH7^QTr09LT8PMIVyMRP8bGHX`M%zFFz4YxbF z884Yx+a(=q*k||Tni3GLb3ftpj%PTy;m0ep#E0p-G0F0cuJUUB;}1;|O&h))^5M?z z)BRk}^TiADzVA0&y5yBSb`hPKm7d9`xJhd}wV8U`k*%EHugHjMa-AfbO4>?lndxUZ z`PWJMg-8CTT*Wp+f#F7l9TQwhss{{`FoF8eO*Or^_UR(RbK05N^ouxK_!HL=b5z^=U(y%ulZXC>UjDU(MekWzK+;TQJYH;bzk6`YJk#TkxDg@R(mv z@ce{daERf2%RGmbBRk;KZ2NOVU)9c%*;7Cc2)6k25TEXY@k*W4@^{o?e_hD?>ly}C zAR(sH*jp;^jCgd4a?B5Jhy+_+`&s%L=-Qy5L+of8rok0xgrsc0B&w~D?3^Ya95 zqKU#ZJOww=yJ2pglAF&0U}m18n;6%yFi#mNGyqH<`9=yo9cF_R3Y3t-D8ZYJb{O(O z^dhAKrNLNNHH*>IdOBO0jvSBgro`N0TY`8JR(J5MTlu6RUj9bXq)&n zG62?x*g`S{@__-{0LDlFEFLk0Bt>zC5=s-7Mry%o5DQ3Z6n7}GG{7Q~4@Qn;LkWap zLGUeNnukOYMMxf$NGJ}3U?=8u2!M!3vY`0yF~jj?VoHbj5P3*0l<+-vIDr=I6mgBj zL9yK9JrYJl4ZwB~r$_*btZl|iNjs{ zi@8xWc~hvODa>v&dS%xy5V##Fx~mZ=xElP@v9Tl)^7AU$MbG;iDC?g#S*p)}U zk&aH^wLuAmN=RdrCeFef_I!}ND5+3s2%1F#AME*_8nOx{1|hUaYla%^HXxT!G@(2Y zVvBSSsOWAHavDVy$^{|XNjrrG?DiqIPz<4b5Wr44BNVV3j~qgg-gAZ%%A}P-wRUTe z3n=P)?r>t6bPFioE;)+rULYK6Ajx8=c~2BsgyOju3C9^o-WfXG10du78HfK7Ga^Z5 zsC17HnTO)K7kgtMP8$D?pYr3o>C$P2X=RmrzpTZ$0Na0>eFCN!Uqf{(yCYT zMiV+E_`09TH0Fh-=Uy9YxH$gHD3F9}b_kxx^}*dcBu`{R;N~5oC-Qgj@D3UJw>WTF z-#7Gf@o+0&F?!i|a2;PEdii$UYJ9yqr6j`o1v=qFLy5Gs8uCL0iA2rnAZNIQu@Sk?h<al^~c9=iAP1gF~IQ+3rl_ZARw z*hy7LE^q=TCf6-EEOqcDN7y7_j@ljw^rrH4Pu@#0UKV3C;vgLRb=d}4Vk{Ez1BJ6A z)gv+(#8`?CmV75WVtg%Aeb;@a{^+h4(QRyI{<^o#ATr~pcG>jLRc&(P?Uu-0X%)Wn z?WF!8wRPShGd8JTf#p^ssDAC*Zt-KtcPmP8IoxZobtu#QEL>H^fQ}+7{Lo%BgubT1 z$4#(}BL6|?>3YF!lzP94x?uawUhuNmnEzDf)s*inHO~F!ANxjVN2BJeIW<|Avc|`k zoJtRh4YY(w_g`e(*S}f01`l8Q>6X z|4wbum_Xk^Qhen%W_e9}6GH%ZpP0Z_?y+8oQ9BobcWhAUR~Ibm2+LrJ1!~8%3=)wO zoOQR(=^4-Yi?0j7Y{LBmMnms()tsU3rmIIt6K*vhTNzvqqk;O9XBquYcXKEOZ$h zRi(M5O*L+)UNkar%8Ie@C#T|=?BEmV%j7HT^{x?lDhIj=5bZ67^s>+n z!-?0rQU@!QrqS5y=$f=u#vdtrbUqZO)8iX0ueL`(OEUPrmvZ; zSu4a)p>Bpco0)DQI#i%Wm#I1S_$cHa#lyF~p}e{G_x z%WkZ84xy(~FTLFPnYHMjzxSTmA;`y>`J}eOGYw$a9JRk$=-?JI)jv+1>0>^htI=Ud zbs}|uwcp$9P(jkoPU-rZVMKLW<&|6NSGEysjL`$c5tz|9>P_x*oy1Ysc!Hc|Q!Bce ziTAH6y_w%R#^+9R93D^~t8Tr@XSs4ula!EzZHLdy_VhRg}2h*bwb8A72kDc*srba5Y0t~p4vRq-Z=g~ z^)lLlyt8-UO!f5U<$R^!j3b{WpK14!1=G*T;83-(B0(JvRh}>V?j<%;OOqW7e}}ab zM7}kzHFWLwu|D$>NK97rjaZ%*ey7>qs0bvG?4_@vFjbJ)ut)qQ zVDgeDLQ&SZ-Ov4f2fXpOYbQzA?f9)x$&ZH_*E{co2|v)^%5iYx4Lq4}PxJFCD(Hfm zwCeIuwWI#0DnIXyjv~TkcE$L$33rB@s@1QF4L^AKyN52d@*Osp<9YUg0&t6lyhrA` z>^tdfKdYl+Gy0$9UARN^`EHQRM(3(l|07rEuMT?b^_`oDnjeM>*}ph(n%CSZepc&u z8fPnM@c0N5ZH&ui$p$An@p5ZO1G^wBgHwJ+-1j=uuZjmQ*vFFxS_3z)r*yhTcRJ+L zr+919y!)jVx}yC#%e5R4>W(2*s|p_)T;u888s0B(jgDWLnF zRw|*+A!%Mh!Q^#k$@?Lzsfc^IegX30eqnL&)RKQvw@_WLzp2lUO#TJGXi9*sySsCg z%gkgN@s{G2{!s3i-fsYo)kSrFj1NNSU_=4O{BV ziD*uO3ed6Jma8?E0ja5?C*`0X=6@;QKIlp5Vd+pR=#ebhh8$&Mt>lr@_A|{n?|S#E ze#ta60<*g;esj?PFMo6434S?ejK1|UEk{hh?F(7P|7ux{G|_J`t#Dx^v6-%ZHW%t| zm5TSal1uPvc>%xC>k0nT?N;-;|NaQx%q;1tBe2#a@rfoeTU2;1Jg=zXt3&=jRX0r% zB3U6!rixl&%=y}?kemc1Dy-`YoM;jqPAV)>JEzxh-Ksj3%Ky3{mi97nH*W*ha$6p@ zENy1I|0VROI4Hf|lg1{uQW*kHCru5xp{ zOVwHfVOdUD+*8#+16Uu~b`G*BHh>Mx_1z5bf14tdeGyFp&tbxqCs7Y>hT*zn4u1C0 zB9Z$_2G=tq@sq{-uBXD%i)y#I4b7?Y{stqQw#79K_RcEh3{>%zpQ zt2MO)?&U{q57wJ9ff_QGFc$>kl(=KR+g*VAf2sQ)pU?~Oo1D?mo*4+$ IH>08b4`|GD*#H0l literal 0 HcmV?d00001 diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff2 b/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..7eb74fd127ee5eddf3b95fee6a20dc1684b0963b GIT binary patch literal 71896 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≠dR0E9ICQ{-tcR;@{R^I5P#1GUH!p=-{c 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 literal 0 HcmV?d00001 diff --git a/docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js b/docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js new file mode 100644 index 000000000..ff7be7141 --- /dev/null +++ b/docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js @@ -0,0 +1,240 @@ +require(['gitbook', 'jquery'], function(gitbook, $) { + // Configuration + var MAX_SIZE = 4, + MIN_SIZE = 0, + BUTTON_ID; + + // Current fontsettings state + var fontState; + + // Default themes + var THEMES = [ + { + config: 'white', + text: 'White', + id: 0 + }, + { + config: 'sepia', + text: 'Sepia', + id: 1 + }, + { + config: 'night', + text: 'Night', + id: 2 + } + ]; + + // Default font families + var FAMILIES = [ + { + config: 'serif', + text: 'Serif', + id: 0 + }, + { + config: 'sans', + text: 'Sans', + id: 1 + } + ]; + + // Return configured themes + function getThemes() { + return THEMES; + } + + // Modify configured themes + function setThemes(themes) { + THEMES = themes; + updateButtons(); + } + + // Return configured font families + function getFamilies() { + return FAMILIES; + } + + // Modify configured font families + function setFamilies(families) { + FAMILIES = families; + updateButtons(); + } + + // Save current font settings + function saveFontSettings() { + gitbook.storage.set('fontState', fontState); + update(); + } + + // Increase font size + function enlargeFontSize(e) { + e.preventDefault(); + if (fontState.size >= MAX_SIZE) return; + + fontState.size++; + saveFontSettings(); + } + + // Decrease font size + function reduceFontSize(e) { + e.preventDefault(); + if (fontState.size <= MIN_SIZE) return; + + fontState.size--; + saveFontSettings(); + } + + // Change font family + function changeFontFamily(configName, e) { + if (e && e instanceof Event) { + e.preventDefault(); + } + + var familyId = getFontFamilyId(configName); + fontState.family = familyId; + saveFontSettings(); + } + + // Change type of color theme + function changeColorTheme(configName, e) { + if (e && e instanceof Event) { + e.preventDefault(); + } + + var $book = gitbook.state.$book; + + // Remove currently applied color theme + if (fontState.theme !== 0) + $book.removeClass('color-theme-'+fontState.theme); + + // Set new color theme + var themeId = getThemeId(configName); + fontState.theme = themeId; + if (fontState.theme !== 0) + $book.addClass('color-theme-'+fontState.theme); + + saveFontSettings(); + } + + // Return the correct id for a font-family config key + // Default to first font-family + function getFontFamilyId(configName) { + // Search for plugin configured font family + var configFamily = $.grep(FAMILIES, function(family) { + return family.config == configName; + })[0]; + // Fallback to default font family + return (!!configFamily)? configFamily.id : 0; + } + + // Return the correct id for a theme config key + // Default to first theme + function getThemeId(configName) { + // Search for plugin configured theme + var configTheme = $.grep(THEMES, function(theme) { + return theme.config == configName; + })[0]; + // Fallback to default theme + return (!!configTheme)? configTheme.id : 0; + } + + function update() { + var $book = gitbook.state.$book; + + $('.font-settings .font-family-list li').removeClass('active'); + $('.font-settings .font-family-list li:nth-child('+(fontState.family+1)+')').addClass('active'); + + $book[0].className = $book[0].className.replace(/\bfont-\S+/g, ''); + $book.addClass('font-size-'+fontState.size); + $book.addClass('font-family-'+fontState.family); + + if(fontState.theme !== 0) { + $book[0].className = $book[0].className.replace(/\bcolor-theme-\S+/g, ''); + $book.addClass('color-theme-'+fontState.theme); + } + } + + function init(config) { + // Search for plugin configured font family + var configFamily = getFontFamilyId(config.family), + configTheme = getThemeId(config.theme); + + // Instantiate font state object + fontState = gitbook.storage.get('fontState', { + size: config.size || 2, + family: configFamily, + theme: configTheme + }); + + update(); + } + + function updateButtons() { + // Remove existing fontsettings buttons + if (!!BUTTON_ID) { + gitbook.toolbar.removeButton(BUTTON_ID); + } + + // Create buttons in toolbar + BUTTON_ID = gitbook.toolbar.createButton({ + icon: 'fa fa-font', + label: 'Font Settings', + className: 'font-settings', + dropdown: [ + [ + { + text: 'A', + className: 'font-reduce', + onClick: reduceFontSize + }, + { + text: 'A', + className: 'font-enlarge', + onClick: enlargeFontSize + } + ], + $.map(FAMILIES, function(family) { + family.onClick = function(e) { + return changeFontFamily(family.config, e); + }; + + return family; + }), + $.map(THEMES, function(theme) { + theme.onClick = function(e) { + return changeColorTheme(theme.config, e); + }; + + return theme; + }) + ] + }); + } + + // Init configuration at start + gitbook.events.bind('start', function(e, config) { + var opts = config.fontsettings; + + // Generate buttons at start + updateButtons(); + + // Init current settings + init(opts); + }); + + // Expose API + gitbook.fontsettings = { + enlargeFontSize: enlargeFontSize, + reduceFontSize: reduceFontSize, + setTheme: changeColorTheme, + setFamily: changeFontFamily, + getThemes: getThemes, + setThemes: setThemes, + getFamilies: getFamilies, + setFamilies: setFamilies + }; +}); + + diff --git a/docs/book/gitbook/gitbook-plugin-fontsettings/website.css b/docs/book/gitbook/gitbook-plugin-fontsettings/website.css new file mode 100644 index 000000000..26591fe81 --- /dev/null +++ b/docs/book/gitbook/gitbook-plugin-fontsettings/website.css @@ -0,0 +1,291 @@ +/* + * Theme 1 + */ +.color-theme-1 .dropdown-menu { + background-color: #111111; + border-color: #7e888b; +} +.color-theme-1 .dropdown-menu .dropdown-caret .caret-inner { + border-bottom: 9px solid #111111; +} +.color-theme-1 .dropdown-menu .buttons { + border-color: #7e888b; +} +.color-theme-1 .dropdown-menu .button { + color: #afa790; +} +.color-theme-1 .dropdown-menu .button:hover { + color: #73553c; +} +/* + * Theme 2 + */ +.color-theme-2 .dropdown-menu { + background-color: #2d3143; + border-color: #272a3a; +} +.color-theme-2 .dropdown-menu .dropdown-caret .caret-inner { + border-bottom: 9px solid #2d3143; +} +.color-theme-2 .dropdown-menu .buttons { + border-color: #272a3a; +} +.color-theme-2 .dropdown-menu .button { + color: #62677f; +} +.color-theme-2 .dropdown-menu .button:hover { + color: #f4f4f5; +} +.book .book-header .font-settings .font-enlarge { + line-height: 30px; + font-size: 1.4em; +} +.book .book-header .font-settings .font-reduce { + line-height: 30px; + font-size: 1em; +} +.book.color-theme-1 .book-body { + color: #704214; + background: #f3eacb; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section { + background: #f3eacb; +} +.book.color-theme-2 .book-body { + color: #bdcadb; + background: #1c1f2b; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section { + background: #1c1f2b; +} +.book.font-size-0 .book-body .page-inner section { + font-size: 1.2rem; +} +.book.font-size-1 .book-body .page-inner section { + font-size: 1.4rem; +} +.book.font-size-2 .book-body .page-inner section { + font-size: 1.6rem; +} +.book.font-size-3 .book-body .page-inner section { + font-size: 2.2rem; +} +.book.font-size-4 .book-body .page-inner section { + font-size: 4rem; +} +.book.font-family-0 { + font-family: Georgia, serif; +} +.book.font-family-1 { + font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal { + color: #704214; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal a { + color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h1, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h2, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h3, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h4, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h5, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h6 { + color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h1, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h2 { + border-color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h6 { + color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal hr { + background-color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal blockquote { + border-color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code { + background: #fdf6e3; + color: #657b83; + border-color: #f8df9c; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal .highlight { + background-color: inherit; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table th, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table td { + border-color: #f5d06c; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table tr { + color: inherit; + background-color: #fdf6e3; + border-color: #444444; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table tr:nth-child(2n) { + background-color: #fbeecb; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal { + color: #bdcadb; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal a { + color: #3eb1d0; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h1, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h2, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h3, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h4, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h5, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h6 { + color: #fffffa; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h1, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h2 { + border-color: #373b4e; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h6 { + color: #373b4e; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal hr { + background-color: #373b4e; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal blockquote { + border-color: #373b4e; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code { + color: #9dbed8; + background: #2d3143; + border-color: #2d3143; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal .highlight { + background-color: #282a39; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table th, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table td { + border-color: #3b3f54; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table tr { + color: #b6c2d2; + background-color: #2d3143; + border-color: #3b3f54; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table tr:nth-child(2n) { + background-color: #35394b; +} +.book.color-theme-1 .book-header { + color: #afa790; + background: transparent; +} +.book.color-theme-1 .book-header .btn { + color: #afa790; +} +.book.color-theme-1 .book-header .btn:hover { + color: #73553c; + background: none; +} +.book.color-theme-1 .book-header h1 { + color: #704214; +} +.book.color-theme-2 .book-header { + color: #7e888b; + background: transparent; +} +.book.color-theme-2 .book-header .btn { + color: #3b3f54; +} +.book.color-theme-2 .book-header .btn:hover { + color: #fffff5; + background: none; +} +.book.color-theme-2 .book-header h1 { + color: #bdcadb; +} +.book.color-theme-1 .book-body .navigation { + color: #afa790; +} +.book.color-theme-1 .book-body .navigation:hover { + color: #73553c; +} +.book.color-theme-2 .book-body .navigation { + color: #383f52; +} +.book.color-theme-2 .book-body .navigation:hover { + color: #fffff5; +} +/* + * Theme 1 + */ +.book.color-theme-1 .book-summary { + color: #afa790; + background: #111111; + border-right: 1px solid rgba(0, 0, 0, 0.07); +} +.book.color-theme-1 .book-summary .book-search { + background: transparent; +} +.book.color-theme-1 .book-summary .book-search input, +.book.color-theme-1 .book-summary .book-search input:focus { + border: 1px solid transparent; +} +.book.color-theme-1 .book-summary ul.summary li.divider { + background: #7e888b; + box-shadow: none; +} +.book.color-theme-1 .book-summary ul.summary li i.fa-check { + color: #33cc33; +} +.book.color-theme-1 .book-summary ul.summary li.done > a { + color: #877f6a; +} +.book.color-theme-1 .book-summary ul.summary li a, +.book.color-theme-1 .book-summary ul.summary li span { + color: #877f6a; + background: transparent; + font-weight: normal; +} +.book.color-theme-1 .book-summary ul.summary li.active > a, +.book.color-theme-1 .book-summary ul.summary li a:hover { + color: #704214; + background: transparent; + font-weight: normal; +} +/* + * Theme 2 + */ +.book.color-theme-2 .book-summary { + color: #bcc1d2; + background: #2d3143; + border-right: none; +} +.book.color-theme-2 .book-summary .book-search { + background: transparent; +} +.book.color-theme-2 .book-summary .book-search input, +.book.color-theme-2 .book-summary .book-search input:focus { + border: 1px solid transparent; +} +.book.color-theme-2 .book-summary ul.summary li.divider { + background: #272a3a; + box-shadow: none; +} +.book.color-theme-2 .book-summary ul.summary li i.fa-check { + color: #33cc33; +} +.book.color-theme-2 .book-summary ul.summary li.done > a { + color: #62687f; +} +.book.color-theme-2 .book-summary ul.summary li a, +.book.color-theme-2 .book-summary ul.summary li span { + color: #c1c6d7; + background: transparent; + font-weight: 600; +} +.book.color-theme-2 .book-summary ul.summary li.active > a, +.book.color-theme-2 .book-summary ul.summary li a:hover { + color: #f4f4f5; + background: #252737; + font-weight: 600; +} diff --git a/docs/book/gitbook/gitbook-plugin-highlight/ebook.css b/docs/book/gitbook/gitbook-plugin-highlight/ebook.css new file mode 100644 index 000000000..cecaaab5a --- /dev/null +++ b/docs/book/gitbook/gitbook-plugin-highlight/ebook.css @@ -0,0 +1,135 @@ +pre, +code { + /* http://jmblog.github.io/color-themes-for-highlightjs */ + /* Tomorrow Comment */ + /* Tomorrow Red */ + /* Tomorrow Orange */ + /* Tomorrow Yellow */ + /* Tomorrow Green */ + /* Tomorrow Aqua */ + /* Tomorrow Blue */ + /* Tomorrow Purple */ +} +pre .hljs-comment, +code .hljs-comment, +pre .hljs-title, +code .hljs-title { + color: #8e908c; +} +pre .hljs-variable, +code .hljs-variable, +pre .hljs-attribute, +code .hljs-attribute, +pre .hljs-tag, +code .hljs-tag, +pre .hljs-regexp, +code .hljs-regexp, +pre .hljs-deletion, +code .hljs-deletion, +pre .ruby .hljs-constant, +code .ruby .hljs-constant, +pre .xml .hljs-tag .hljs-title, +code .xml .hljs-tag .hljs-title, +pre .xml .hljs-pi, +code .xml .hljs-pi, +pre .xml .hljs-doctype, +code .xml .hljs-doctype, +pre .html .hljs-doctype, +code .html .hljs-doctype, +pre .css .hljs-id, +code .css .hljs-id, +pre .css .hljs-class, +code .css .hljs-class, +pre .css .hljs-pseudo, +code .css .hljs-pseudo { + color: #c82829; +} +pre .hljs-number, +code .hljs-number, +pre .hljs-preprocessor, +code .hljs-preprocessor, +pre .hljs-pragma, +code .hljs-pragma, +pre .hljs-built_in, +code .hljs-built_in, +pre .hljs-literal, +code .hljs-literal, +pre .hljs-params, +code .hljs-params, +pre .hljs-constant, +code .hljs-constant { + color: #f5871f; +} +pre .ruby .hljs-class .hljs-title, +code .ruby .hljs-class .hljs-title, +pre .css .hljs-rules .hljs-attribute, +code .css .hljs-rules .hljs-attribute { + color: #eab700; +} +pre .hljs-string, +code .hljs-string, +pre .hljs-value, +code .hljs-value, +pre .hljs-inheritance, +code .hljs-inheritance, +pre .hljs-header, +code .hljs-header, +pre .hljs-addition, +code .hljs-addition, +pre .ruby .hljs-symbol, +code .ruby .hljs-symbol, +pre .xml .hljs-cdata, +code .xml .hljs-cdata { + color: #718c00; +} +pre .css .hljs-hexcolor, +code .css .hljs-hexcolor { + color: #3e999f; +} +pre .hljs-function, +code .hljs-function, +pre .python .hljs-decorator, +code .python .hljs-decorator, +pre .python .hljs-title, +code .python .hljs-title, +pre .ruby .hljs-function .hljs-title, +code .ruby .hljs-function .hljs-title, +pre .ruby .hljs-title .hljs-keyword, +code .ruby .hljs-title .hljs-keyword, +pre .perl .hljs-sub, +code .perl .hljs-sub, +pre .javascript .hljs-title, +code .javascript .hljs-title, +pre .coffeescript .hljs-title, +code .coffeescript .hljs-title { + color: #4271ae; +} +pre .hljs-keyword, +code .hljs-keyword, +pre .javascript .hljs-function, +code .javascript .hljs-function { + color: #8959a8; +} +pre .hljs, +code .hljs { + display: block; + background: white; + color: #4d4d4c; + padding: 0.5em; +} +pre .coffeescript .javascript, +code .coffeescript .javascript, +pre .javascript .xml, +code .javascript .xml, +pre .tex .hljs-formula, +code .tex .hljs-formula, +pre .xml .javascript, +code .xml .javascript, +pre .xml .vbscript, +code .xml .vbscript, +pre .xml .css, +code .xml .css, +pre .xml .hljs-cdata, +code .xml .hljs-cdata { + opacity: 0.5; +} diff --git a/docs/book/gitbook/gitbook-plugin-highlight/website.css b/docs/book/gitbook/gitbook-plugin-highlight/website.css new file mode 100644 index 000000000..6674448f7 --- /dev/null +++ b/docs/book/gitbook/gitbook-plugin-highlight/website.css @@ -0,0 +1,434 @@ +.book .book-body .page-wrapper .page-inner section.normal pre, +.book .book-body .page-wrapper .page-inner section.normal code { + /* http://jmblog.github.com/color-themes-for-google-code-highlightjs */ + /* Tomorrow Comment */ + /* Tomorrow Red */ + /* Tomorrow Orange */ + /* Tomorrow Yellow */ + /* Tomorrow Green */ + /* Tomorrow Aqua */ + /* Tomorrow Blue */ + /* Tomorrow Purple */ +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-comment, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-comment, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-title { + color: #8e908c; +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-variable, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-variable, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-attribute, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-attribute, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-tag, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-tag, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-regexp, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-regexp, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-deletion, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-deletion, +.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-constant, +.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-constant, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-tag .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-tag .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-pi, +.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-pi, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-doctype, +.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-doctype, +.book .book-body .page-wrapper .page-inner section.normal pre .html .hljs-doctype, +.book .book-body .page-wrapper .page-inner section.normal code .html .hljs-doctype, +.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-id, +.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-id, +.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-class, +.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-class, +.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-pseudo, +.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-pseudo { + color: #c82829; +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-number, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-number, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-pragma, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-pragma, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-built_in, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-built_in, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-literal, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-literal, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-params, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-params, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-constant, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-constant { + color: #f5871f; +} +.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-class .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-class .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-rules .hljs-attribute, +.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-rules .hljs-attribute { + color: #eab700; +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-string, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-string, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-value, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-value, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-inheritance, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-inheritance, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-header, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-header, +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-addition, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-addition, +.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-symbol, +.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-symbol, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, +.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { + color: #718c00; +} +.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-hexcolor, +.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-hexcolor { + color: #3e999f; +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-function, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-function, +.book .book-body .page-wrapper .page-inner section.normal pre .python .hljs-decorator, +.book .book-body .page-wrapper .page-inner section.normal code .python .hljs-decorator, +.book .book-body .page-wrapper .page-inner section.normal pre .python .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .python .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-function .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-function .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-title .hljs-keyword, +.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-title .hljs-keyword, +.book .book-body .page-wrapper .page-inner section.normal pre .perl .hljs-sub, +.book .book-body .page-wrapper .page-inner section.normal code .perl .hljs-sub, +.book .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal pre .coffeescript .hljs-title, +.book .book-body .page-wrapper .page-inner section.normal code .coffeescript .hljs-title { + color: #4271ae; +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs-keyword, +.book .book-body .page-wrapper .page-inner section.normal code .hljs-keyword, +.book .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-function, +.book .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-function { + color: #8959a8; +} +.book .book-body .page-wrapper .page-inner section.normal pre .hljs, +.book .book-body .page-wrapper .page-inner section.normal code .hljs { + display: block; + background: white; + color: #4d4d4c; + padding: 0.5em; +} +.book .book-body .page-wrapper .page-inner section.normal pre .coffeescript .javascript, +.book .book-body .page-wrapper .page-inner section.normal code .coffeescript .javascript, +.book .book-body .page-wrapper .page-inner section.normal pre .javascript .xml, +.book .book-body .page-wrapper .page-inner section.normal code .javascript .xml, +.book .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, +.book .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .javascript, +.book .book-body .page-wrapper .page-inner section.normal code .xml .javascript, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .vbscript, +.book .book-body .page-wrapper .page-inner section.normal code .xml .vbscript, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .css, +.book .book-body .page-wrapper .page-inner section.normal code .xml .css, +.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, +.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { + opacity: 0.5; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code { + /* + +Orginal Style from ethanschoonover.com/solarized (c) Jeremy Hull + +*/ + /* Solarized Green */ + /* Solarized Cyan */ + /* Solarized Blue */ + /* Solarized Yellow */ + /* Solarized Orange */ + /* Solarized Red */ + /* Solarized Violet */ +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs { + display: block; + padding: 0.5em; + background: #fdf6e3; + color: #657b83; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-comment, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-comment, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-template_comment, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-template_comment, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .diff .hljs-header, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .diff .hljs-header, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-doctype, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-doctype, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-pi, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-pi, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .lisp .hljs-string, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .lisp .hljs-string, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-javadoc, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-javadoc { + color: #93a1a1; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-keyword, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-keyword, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-winutils, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-winutils, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .method, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .method, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-addition, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-addition, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-tag, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .css .hljs-tag, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-request, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-request, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-status, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-status, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .nginx .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .nginx .hljs-title { + color: #859900; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-number, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-number, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-command, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-command, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-string, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-string, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-tag .hljs-value, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-tag .hljs-value, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-rules .hljs-value, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-rules .hljs-value, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-phpdoc, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-phpdoc, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-regexp, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-regexp, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-hexcolor, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-hexcolor, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-link_url, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-link_url { + color: #2aa198; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-localvars, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-localvars, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-chunk, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-chunk, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-decorator, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-decorator, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-built_in, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-built_in, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-identifier, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-identifier, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .vhdl .hljs-literal, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .vhdl .hljs-literal, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-id, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-id, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-function, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .css .hljs-function { + color: #268bd2; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-attribute, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-attribute, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-variable, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-variable, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .lisp .hljs-body, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .lisp .hljs-body, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .smalltalk .hljs-number, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .smalltalk .hljs-number, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-constant, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-constant, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-class .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-class .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-parent, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-parent, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .haskell .hljs-type, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .haskell .hljs-type, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-link_reference, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-link_reference { + color: #b58900; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor .hljs-keyword, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor .hljs-keyword, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-pragma, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-pragma, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-shebang, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-shebang, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-symbol, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-symbol, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-symbol .hljs-string, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-symbol .hljs-string, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .diff .hljs-change, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .diff .hljs-change, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-special, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-special, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-attr_selector, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-attr_selector, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-subst, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-subst, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-cdata, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-cdata, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .clojure .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .clojure .hljs-title, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-pseudo, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .css .hljs-pseudo, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-header, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-header { + color: #cb4b16; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-deletion, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-deletion, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-important, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-important { + color: #dc322f; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-link_label, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-link_label { + color: #6c71c4; +} +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, +.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula { + background: #eee8d5; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code { + /* Tomorrow Night Bright Theme */ + /* Original theme - https://github.com/chriskempson/tomorrow-theme */ + /* http://jmblog.github.com/color-themes-for-google-code-highlightjs */ + /* Tomorrow Comment */ + /* Tomorrow Red */ + /* Tomorrow Orange */ + /* Tomorrow Yellow */ + /* Tomorrow Green */ + /* Tomorrow Aqua */ + /* Tomorrow Blue */ + /* Tomorrow Purple */ +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-comment, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-comment, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-title { + color: #969896; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-variable, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-variable, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-attribute, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-attribute, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-tag, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-tag, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-regexp, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-regexp, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-deletion, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-deletion, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-constant, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-constant, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-tag .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-tag .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-pi, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-pi, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-doctype, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-doctype, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .html .hljs-doctype, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .html .hljs-doctype, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-id, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-id, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-class, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-class, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-pseudo, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-pseudo { + color: #d54e53; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-number, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-number, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-pragma, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-pragma, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-built_in, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-built_in, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-literal, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-literal, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-params, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-params, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-constant, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-constant { + color: #e78c45; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-class .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-class .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-rules .hljs-attribute, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-rules .hljs-attribute { + color: #e7c547; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-string, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-string, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-value, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-value, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-inheritance, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-inheritance, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-header, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-header, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-addition, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-addition, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-symbol, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-symbol, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { + color: #b9ca4a; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-hexcolor, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-hexcolor { + color: #70c0b1; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-function, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-function, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .python .hljs-decorator, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .python .hljs-decorator, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .python .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .python .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-function .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-function .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-title .hljs-keyword, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-title .hljs-keyword, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .perl .hljs-sub, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .perl .hljs-sub, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .coffeescript .hljs-title, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .coffeescript .hljs-title { + color: #7aa6da; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-keyword, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-keyword, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-function, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-function { + color: #c397d8; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs { + display: block; + background: black; + color: #eaeaea; + padding: 0.5em; +} +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .coffeescript .javascript, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .coffeescript .javascript, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .javascript .xml, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .javascript .xml, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .javascript, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .javascript, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .vbscript, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .vbscript, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .css, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .css, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, +.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { + opacity: 0.5; +} diff --git a/docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js b/docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js new file mode 100644 index 000000000..6aa6bc7d6 --- /dev/null +++ b/docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js @@ -0,0 +1,7 @@ +/** + * lunr - http://lunrjs.com - A bit like Solr, but much smaller and not as bright - 0.5.12 + * Copyright (C) 2015 Oliver Nightingale + * MIT Licensed + * @license + */ +!function(){var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.5.12",t.utils={},t.utils.warn=function(t){return function(e){t.console&&console.warn&&console.warn(e)}}(this),t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var t=Array.prototype.slice.call(arguments),e=t.pop(),n=t;if("function"!=typeof e)throw new TypeError("last argument must be a function");n.forEach(function(t){this.hasHandler(t)||(this.events[t]=[]),this.events[t].push(e)},this)},t.EventEmitter.prototype.removeListener=function(t,e){if(this.hasHandler(t)){var n=this.events[t].indexOf(e);this.events[t].splice(n,1),this.events[t].length||delete this.events[t]}},t.EventEmitter.prototype.emit=function(t){if(this.hasHandler(t)){var e=Array.prototype.slice.call(arguments,1);this.events[t].forEach(function(t){t.apply(void 0,e)})}},t.EventEmitter.prototype.hasHandler=function(t){return t in this.events},t.tokenizer=function(t){return arguments.length&&null!=t&&void 0!=t?Array.isArray(t)?t.map(function(t){return t.toLowerCase()}):t.toString().trim().toLowerCase().split(/[\s\-]+/):[]},t.Pipeline=function(){this._stack=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in this.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[e.label]=e},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.registeredFunctions[e];if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._stack.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._stack.indexOf(e);if(-1==i)throw new Error("Cannot find existingFn");i+=1,this._stack.splice(i,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._stack.indexOf(e);if(-1==i)throw new Error("Cannot find existingFn");this._stack.splice(i,0,n)},t.Pipeline.prototype.remove=function(t){var e=this._stack.indexOf(t);-1!=e&&this._stack.splice(e,1)},t.Pipeline.prototype.run=function(t){for(var e=[],n=t.length,i=this._stack.length,o=0;n>o;o++){for(var r=t[o],s=0;i>s&&(r=this._stack[s](r,o,t),void 0!==r);s++);void 0!==r&&e.push(r)}return e},t.Pipeline.prototype.reset=function(){this._stack=[]},t.Pipeline.prototype.toJSON=function(){return this._stack.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Vector=function(){this._magnitude=null,this.list=void 0,this.length=0},t.Vector.Node=function(t,e,n){this.idx=t,this.val=e,this.next=n},t.Vector.prototype.insert=function(e,n){this._magnitude=void 0;var i=this.list;if(!i)return this.list=new t.Vector.Node(e,n,i),this.length++;if(en.idx?n=n.next:(i+=e.val*n.val,e=e.next,n=n.next);return i},t.Vector.prototype.similarity=function(t){return this.dot(t)/(this.magnitude()*t.magnitude())},t.SortedSet=function(){this.length=0,this.elements=[]},t.SortedSet.load=function(t){var e=new this;return e.elements=t,e.length=t.length,e},t.SortedSet.prototype.add=function(){var t,e;for(t=0;t1;){if(r===t)return o;t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o]}return r===t?o:-1},t.SortedSet.prototype.locationFor=function(t){for(var e=0,n=this.elements.length,i=n-e,o=e+Math.floor(i/2),r=this.elements[o];i>1;)t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o];return r>t?o:t>r?o+1:void 0},t.SortedSet.prototype.intersect=function(e){for(var n=new t.SortedSet,i=0,o=0,r=this.length,s=e.length,a=this.elements,h=e.elements;;){if(i>r-1||o>s-1)break;a[i]!==h[o]?a[i]h[o]&&o++:(n.add(a[i]),i++,o++)}return n},t.SortedSet.prototype.clone=function(){var e=new t.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},t.SortedSet.prototype.union=function(t){var e,n,i;return this.length>=t.length?(e=this,n=t):(e=t,n=this),i=e.clone(),i.add.apply(i,n.toArray()),i},t.SortedSet.prototype.toJSON=function(){return this.toArray()},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.Store,this.tokenStore=new t.TokenStore,this.corpusTokens=new t.SortedSet,this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var t=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,t)},t.Index.prototype.off=function(t,e){return this.eventEmitter.removeListener(t,e)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;return n._fields=e.fields,n._ref=e.ref,n.documentStore=t.Store.load(e.documentStore),n.tokenStore=t.TokenStore.load(e.tokenStore),n.corpusTokens=t.SortedSet.load(e.corpusTokens),n.pipeline=t.Pipeline.load(e.pipeline),n},t.Index.prototype.field=function(t,e){var e=e||{},n={name:t,boost:e.boost||1};return this._fields.push(n),this},t.Index.prototype.ref=function(t){return this._ref=t,this},t.Index.prototype.add=function(e,n){var i={},o=new t.SortedSet,r=e[this._ref],n=void 0===n?!0:n;this._fields.forEach(function(n){var r=this.pipeline.run(t.tokenizer(e[n.name]));i[n.name]=r,t.SortedSet.prototype.add.apply(o,r)},this),this.documentStore.set(r,o),t.SortedSet.prototype.add.apply(this.corpusTokens,o.toArray());for(var s=0;s0&&(i=1+Math.log(this.documentStore.length/n)),this._idfCache[e]=i},t.Index.prototype.search=function(e){var n=this.pipeline.run(t.tokenizer(e)),i=new t.Vector,o=[],r=this._fields.reduce(function(t,e){return t+e.boost},0),s=n.some(function(t){return this.tokenStore.has(t)},this);if(!s)return[];n.forEach(function(e,n,s){var a=1/s.length*this._fields.length*r,h=this,l=this.tokenStore.expand(e).reduce(function(n,o){var r=h.corpusTokens.indexOf(o),s=h.idf(o),l=1,u=new t.SortedSet;if(o!==e){var c=Math.max(3,o.length-e.length);l=1/Math.log(c)}return r>-1&&i.insert(r,a*s*l),Object.keys(h.tokenStore.get(o)).forEach(function(t){u.add(t)}),n.union(u)},new t.SortedSet);o.push(l)},this);var a=o.reduce(function(t,e){return t.intersect(e)});return a.map(function(t){return{ref:t,score:i.similarity(this.documentVector(t))}},this).sort(function(t,e){return e.score-t.score})},t.Index.prototype.documentVector=function(e){for(var n=this.documentStore.get(e),i=n.length,o=new t.Vector,r=0;i>r;r++){var s=n.elements[r],a=this.tokenStore.get(s)[e].tf,h=this.idf(s);o.insert(this.corpusTokens.indexOf(s),a*h)}return o},t.Index.prototype.toJSON=function(){return{version:t.version,fields:this._fields,ref:this._ref,documentStore:this.documentStore.toJSON(),tokenStore:this.tokenStore.toJSON(),corpusTokens:this.corpusTokens.toJSON(),pipeline:this.pipeline.toJSON()}},t.Index.prototype.use=function(t){var e=Array.prototype.slice.call(arguments,1);e.unshift(this),t.apply(this,e)},t.Store=function(){this.store={},this.length=0},t.Store.load=function(e){var n=new this;return n.length=e.length,n.store=Object.keys(e.store).reduce(function(n,i){return n[i]=t.SortedSet.load(e.store[i]),n},{}),n},t.Store.prototype.set=function(t,e){this.has(t)||this.length++,this.store[t]=e},t.Store.prototype.get=function(t){return this.store[t]},t.Store.prototype.has=function(t){return t in this.store},t.Store.prototype.remove=function(t){this.has(t)&&(delete this.store[t],this.length--)},t.Store.prototype.toJSON=function(){return{store:this.store,length:this.length}},t.stemmer=function(){var t={ational:"ate",tional:"tion",enci:"ence",anci:"ance",izer:"ize",bli:"ble",alli:"al",entli:"ent",eli:"e",ousli:"ous",ization:"ize",ation:"ate",ator:"ate",alism:"al",iveness:"ive",fulness:"ful",ousness:"ous",aliti:"al",iviti:"ive",biliti:"ble",logi:"log"},e={icate:"ic",ative:"",alize:"al",iciti:"ic",ical:"ic",ful:"",ness:""},n="[^aeiou]",i="[aeiouy]",o=n+"[^aeiouy]*",r=i+"[aeiou]*",s="^("+o+")?"+r+o,a="^("+o+")?"+r+o+"("+r+")?$",h="^("+o+")?"+r+o+r+o,l="^("+o+")?"+i,u=new RegExp(s),c=new RegExp(h),f=new RegExp(a),d=new RegExp(l),p=/^(.+?)(ss|i)es$/,m=/^(.+?)([^s])s$/,v=/^(.+?)eed$/,y=/^(.+?)(ed|ing)$/,g=/.$/,S=/(at|bl|iz)$/,w=new RegExp("([^aeiouylsz])\\1$"),x=new RegExp("^"+o+i+"[^aeiouwxy]$"),k=/^(.+?[^aeiou])y$/,b=/^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/,E=/^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/,_=/^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/,F=/^(.+?)(s|t)(ion)$/,O=/^(.+?)e$/,P=/ll$/,N=new RegExp("^"+o+i+"[^aeiouwxy]$"),T=function(n){var i,o,r,s,a,h,l;if(n.length<3)return n;if(r=n.substr(0,1),"y"==r&&(n=r.toUpperCase()+n.substr(1)),s=p,a=m,s.test(n)?n=n.replace(s,"$1$2"):a.test(n)&&(n=n.replace(a,"$1$2")),s=v,a=y,s.test(n)){var T=s.exec(n);s=u,s.test(T[1])&&(s=g,n=n.replace(s,""))}else if(a.test(n)){var T=a.exec(n);i=T[1],a=d,a.test(i)&&(n=i,a=S,h=w,l=x,a.test(n)?n+="e":h.test(n)?(s=g,n=n.replace(s,"")):l.test(n)&&(n+="e"))}if(s=k,s.test(n)){var T=s.exec(n);i=T[1],n=i+"i"}if(s=b,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+t[o])}if(s=E,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+e[o])}if(s=_,a=F,s.test(n)){var T=s.exec(n);i=T[1],s=c,s.test(i)&&(n=i)}else if(a.test(n)){var T=a.exec(n);i=T[1]+T[2],a=c,a.test(i)&&(n=i)}if(s=O,s.test(n)){var T=s.exec(n);i=T[1],s=c,a=f,h=N,(s.test(i)||a.test(i)&&!h.test(i))&&(n=i)}return s=P,a=c,s.test(n)&&a.test(n)&&(s=g,n=n.replace(s,"")),"y"==r&&(n=r.toLowerCase()+n.substr(1)),n};return T}(),t.Pipeline.registerFunction(t.stemmer,"stemmer"),t.stopWordFilter=function(e){return e&&t.stopWordFilter.stopWords[e]!==e?e:void 0},t.stopWordFilter.stopWords={a:"a",able:"able",about:"about",across:"across",after:"after",all:"all",almost:"almost",also:"also",am:"am",among:"among",an:"an",and:"and",any:"any",are:"are",as:"as",at:"at",be:"be",because:"because",been:"been",but:"but",by:"by",can:"can",cannot:"cannot",could:"could",dear:"dear",did:"did","do":"do",does:"does",either:"either","else":"else",ever:"ever",every:"every","for":"for",from:"from",get:"get",got:"got",had:"had",has:"has",have:"have",he:"he",her:"her",hers:"hers",him:"him",his:"his",how:"how",however:"however",i:"i","if":"if","in":"in",into:"into",is:"is",it:"it",its:"its",just:"just",least:"least",let:"let",like:"like",likely:"likely",may:"may",me:"me",might:"might",most:"most",must:"must",my:"my",neither:"neither",no:"no",nor:"nor",not:"not",of:"of",off:"off",often:"often",on:"on",only:"only",or:"or",other:"other",our:"our",own:"own",rather:"rather",said:"said",say:"say",says:"says",she:"she",should:"should",since:"since",so:"so",some:"some",than:"than",that:"that",the:"the",their:"their",them:"them",then:"then",there:"there",these:"these",they:"they","this":"this",tis:"tis",to:"to",too:"too",twas:"twas",us:"us",wants:"wants",was:"was",we:"we",were:"were",what:"what",when:"when",where:"where",which:"which","while":"while",who:"who",whom:"whom",why:"why",will:"will","with":"with",would:"would",yet:"yet",you:"you",your:"your"},t.Pipeline.registerFunction(t.stopWordFilter,"stopWordFilter"),t.trimmer=function(t){var e=t.replace(/^\W+/,"").replace(/\W+$/,"");return""===e?void 0:e},t.Pipeline.registerFunction(t.trimmer,"trimmer"),t.TokenStore=function(){this.root={docs:{}},this.length=0},t.TokenStore.load=function(t){var e=new this;return e.root=t.root,e.length=t.length,e},t.TokenStore.prototype.add=function(t,e,n){var n=n||this.root,i=t[0],o=t.slice(1);return i in n||(n[i]={docs:{}}),0===o.length?(n[i].docs[e.ref]=e,void(this.length+=1)):this.add(o,e,n[i])},t.TokenStore.prototype.has=function(t){if(!t)return!1;for(var e=this.root,n=0;no;o++){for(var r=t[o],s=0;i>s&&(r=this._stack[s](r,o,t),void 0!==r);s++);void 0!==r&&e.push(r)}return e},t.Pipeline.prototype.reset=function(){this._stack=[]},t.Pipeline.prototype.toJSON=function(){return this._stack.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Vector=function(){this._magnitude=null,this.list=void 0,this.length=0},t.Vector.Node=function(t,e,n){this.idx=t,this.val=e,this.next=n},t.Vector.prototype.insert=function(e,n){this._magnitude=void 0;var i=this.list;if(!i)return this.list=new t.Vector.Node(e,n,i),this.length++;if(en.idx?n=n.next:(i+=e.val*n.val,e=e.next,n=n.next);return i},t.Vector.prototype.similarity=function(t){return this.dot(t)/(this.magnitude()*t.magnitude())},t.SortedSet=function(){this.length=0,this.elements=[]},t.SortedSet.load=function(t){var e=new this;return e.elements=t,e.length=t.length,e},t.SortedSet.prototype.add=function(){var t,e;for(t=0;t1;){if(r===t)return o;t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o]}return r===t?o:-1},t.SortedSet.prototype.locationFor=function(t){for(var e=0,n=this.elements.length,i=n-e,o=e+Math.floor(i/2),r=this.elements[o];i>1;)t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o];return r>t?o:t>r?o+1:void 0},t.SortedSet.prototype.intersect=function(e){for(var n=new t.SortedSet,i=0,o=0,r=this.length,s=e.length,a=this.elements,h=e.elements;;){if(i>r-1||o>s-1)break;a[i]!==h[o]?a[i]h[o]&&o++:(n.add(a[i]),i++,o++)}return n},t.SortedSet.prototype.clone=function(){var e=new t.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},t.SortedSet.prototype.union=function(t){var e,n,i;return this.length>=t.length?(e=this,n=t):(e=t,n=this),i=e.clone(),i.add.apply(i,n.toArray()),i},t.SortedSet.prototype.toJSON=function(){return this.toArray()},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.Store,this.tokenStore=new t.TokenStore,this.corpusTokens=new t.SortedSet,this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var t=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,t)},t.Index.prototype.off=function(t,e){return this.eventEmitter.removeListener(t,e)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;return n._fields=e.fields,n._ref=e.ref,n.documentStore=t.Store.load(e.documentStore),n.tokenStore=t.TokenStore.load(e.tokenStore),n.corpusTokens=t.SortedSet.load(e.corpusTokens),n.pipeline=t.Pipeline.load(e.pipeline),n},t.Index.prototype.field=function(t,e){var e=e||{},n={name:t,boost:e.boost||1};return this._fields.push(n),this},t.Index.prototype.ref=function(t){return this._ref=t,this},t.Index.prototype.add=function(e,n){var i={},o=new t.SortedSet,r=e[this._ref],n=void 0===n?!0:n;this._fields.forEach(function(n){var r=this.pipeline.run(t.tokenizer(e[n.name]));i[n.name]=r,t.SortedSet.prototype.add.apply(o,r)},this),this.documentStore.set(r,o),t.SortedSet.prototype.add.apply(this.corpusTokens,o.toArray());for(var s=0;s0&&(i=1+Math.log(this.documentStore.length/n)),this._idfCache[e]=i},t.Index.prototype.search=function(e){var n=this.pipeline.run(t.tokenizer(e)),i=new t.Vector,o=[],r=this._fields.reduce(function(t,e){return t+e.boost},0),s=n.some(function(t){return this.tokenStore.has(t)},this);if(!s)return[];n.forEach(function(e,n,s){var a=1/s.length*this._fields.length*r,h=this,l=this.tokenStore.expand(e).reduce(function(n,o){var r=h.corpusTokens.indexOf(o),s=h.idf(o),l=1,u=new t.SortedSet;if(o!==e){var c=Math.max(3,o.length-e.length);l=1/Math.log(c)}return r>-1&&i.insert(r,a*s*l),Object.keys(h.tokenStore.get(o)).forEach(function(t){u.add(t)}),n.union(u)},new t.SortedSet);o.push(l)},this);var a=o.reduce(function(t,e){return t.intersect(e)});return a.map(function(t){return{ref:t,score:i.similarity(this.documentVector(t))}},this).sort(function(t,e){return e.score-t.score})},t.Index.prototype.documentVector=function(e){for(var n=this.documentStore.get(e),i=n.length,o=new t.Vector,r=0;i>r;r++){var s=n.elements[r],a=this.tokenStore.get(s)[e].tf,h=this.idf(s);o.insert(this.corpusTokens.indexOf(s),a*h)}return o},t.Index.prototype.toJSON=function(){return{version:t.version,fields:this._fields,ref:this._ref,documentStore:this.documentStore.toJSON(),tokenStore:this.tokenStore.toJSON(),corpusTokens:this.corpusTokens.toJSON(),pipeline:this.pipeline.toJSON()}},t.Index.prototype.use=function(t){var e=Array.prototype.slice.call(arguments,1);e.unshift(this),t.apply(this,e)},t.Store=function(){this.store={},this.length=0},t.Store.load=function(e){var n=new this;return n.length=e.length,n.store=Object.keys(e.store).reduce(function(n,i){return n[i]=t.SortedSet.load(e.store[i]),n},{}),n},t.Store.prototype.set=function(t,e){this.has(t)||this.length++,this.store[t]=e},t.Store.prototype.get=function(t){return this.store[t]},t.Store.prototype.has=function(t){return t in this.store},t.Store.prototype.remove=function(t){this.has(t)&&(delete this.store[t],this.length--)},t.Store.prototype.toJSON=function(){return{store:this.store,length:this.length}},t.stemmer=function(){var t={ational:"ate",tional:"tion",enci:"ence",anci:"ance",izer:"ize",bli:"ble",alli:"al",entli:"ent",eli:"e",ousli:"ous",ization:"ize",ation:"ate",ator:"ate",alism:"al",iveness:"ive",fulness:"ful",ousness:"ous",aliti:"al",iviti:"ive",biliti:"ble",logi:"log"},e={icate:"ic",ative:"",alize:"al",iciti:"ic",ical:"ic",ful:"",ness:""},n="[^aeiou]",i="[aeiouy]",o=n+"[^aeiouy]*",r=i+"[aeiou]*",s="^("+o+")?"+r+o,a="^("+o+")?"+r+o+"("+r+")?$",h="^("+o+")?"+r+o+r+o,l="^("+o+")?"+i,u=new RegExp(s),c=new RegExp(h),f=new RegExp(a),d=new RegExp(l),p=/^(.+?)(ss|i)es$/,m=/^(.+?)([^s])s$/,v=/^(.+?)eed$/,y=/^(.+?)(ed|ing)$/,g=/.$/,S=/(at|bl|iz)$/,w=new RegExp("([^aeiouylsz])\\1$"),x=new RegExp("^"+o+i+"[^aeiouwxy]$"),k=/^(.+?[^aeiou])y$/,b=/^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/,E=/^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/,_=/^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/,F=/^(.+?)(s|t)(ion)$/,O=/^(.+?)e$/,P=/ll$/,N=new RegExp("^"+o+i+"[^aeiouwxy]$"),T=function(n){var i,o,r,s,a,h,l;if(n.length<3)return n;if(r=n.substr(0,1),"y"==r&&(n=r.toUpperCase()+n.substr(1)),s=p,a=m,s.test(n)?n=n.replace(s,"$1$2"):a.test(n)&&(n=n.replace(a,"$1$2")),s=v,a=y,s.test(n)){var T=s.exec(n);s=u,s.test(T[1])&&(s=g,n=n.replace(s,""))}else if(a.test(n)){var T=a.exec(n);i=T[1],a=d,a.test(i)&&(n=i,a=S,h=w,l=x,a.test(n)?n+="e":h.test(n)?(s=g,n=n.replace(s,"")):l.test(n)&&(n+="e"))}if(s=k,s.test(n)){var T=s.exec(n);i=T[1],n=i+"i"}if(s=b,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+t[o])}if(s=E,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+e[o])}if(s=_,a=F,s.test(n)){var T=s.exec(n);i=T[1],s=c,s.test(i)&&(n=i)}else if(a.test(n)){var T=a.exec(n);i=T[1]+T[2],a=c,a.test(i)&&(n=i)}if(s=O,s.test(n)){var T=s.exec(n);i=T[1],s=c,a=f,h=N,(s.test(i)||a.test(i)&&!h.test(i))&&(n=i)}return s=P,a=c,s.test(n)&&a.test(n)&&(s=g,n=n.replace(s,"")),"y"==r&&(n=r.toLowerCase()+n.substr(1)),n};return T}(),t.Pipeline.registerFunction(t.stemmer,"stemmer"),t.stopWordFilter=function(e){return e&&t.stopWordFilter.stopWords[e]!==e?e:void 0},t.stopWordFilter.stopWords={a:"a",able:"able",about:"about",across:"across",after:"after",all:"all",almost:"almost",also:"also",am:"am",among:"among",an:"an",and:"and",any:"any",are:"are",as:"as",at:"at",be:"be",because:"because",been:"been",but:"but",by:"by",can:"can",cannot:"cannot",could:"could",dear:"dear",did:"did","do":"do",does:"does",either:"either","else":"else",ever:"ever",every:"every","for":"for",from:"from",get:"get",got:"got",had:"had",has:"has",have:"have",he:"he",her:"her",hers:"hers",him:"him",his:"his",how:"how",however:"however",i:"i","if":"if","in":"in",into:"into",is:"is",it:"it",its:"its",just:"just",least:"least",let:"let",like:"like",likely:"likely",may:"may",me:"me",might:"might",most:"most",must:"must",my:"my",neither:"neither",no:"no",nor:"nor",not:"not",of:"of",off:"off",often:"often",on:"on",only:"only",or:"or",other:"other",our:"our",own:"own",rather:"rather",said:"said",say:"say",says:"says",she:"she",should:"should",since:"since",so:"so",some:"some",than:"than",that:"that",the:"the",their:"their",them:"them",then:"then",there:"there",these:"these",they:"they","this":"this",tis:"tis",to:"to",too:"too",twas:"twas",us:"us",wants:"wants",was:"was",we:"we",were:"were",what:"what",when:"when",where:"where",which:"which","while":"while",who:"who",whom:"whom",why:"why",will:"will","with":"with",would:"would",yet:"yet",you:"you",your:"your"},t.Pipeline.registerFunction(t.stopWordFilter,"stopWordFilter"),t.trimmer=function(t){var e=t.replace(/^\W+/,"").replace(/\W+$/,"");return""===e?void 0:e},t.Pipeline.registerFunction(t.trimmer,"trimmer"),t.TokenStore=function(){this.root={docs:{}},this.length=0},t.TokenStore.load=function(t){var e=new this;return e.root=t.root,e.length=t.length,e},t.TokenStore.prototype.add=function(t,e,n){var n=n||this.root,i=t[0],o=t.slice(1);return i in n||(n[i]={docs:{}}),0===o.length?(n[i].docs[e.ref]=e,void(this.length+=1)):this.add(o,e,n[i])},t.TokenStore.prototype.has=function(t){if(!t)return!1;for(var e=this.root,n=0;n element for each result + res.results.forEach(function(res) { + var $li = $('

                • ', { + 'class': 'search-results-item' + }); + + var $title = $('

                  '); + + var $link = $('', { + 'href': gitbook.state.basePath + '/' + res.url, + 'text': res.title + }); + + var content = res.body.trim(); + if (content.length > MAX_DESCRIPTION_SIZE) { + content = content.slice(0, MAX_DESCRIPTION_SIZE).trim()+'...'; + } + var $content = $('

                  ').html(content); + + $link.appendTo($title); + $title.appendTo($li); + $content.appendTo($li); + $li.appendTo($searchList); + }); + } + + function launchSearch(q) { + // Add class for loading + $body.addClass('with-search'); + $body.addClass('search-loading'); + + // Launch search query + throttle(gitbook.search.query(q, 0, MAX_RESULTS) + .then(function(results) { + displayResults(results); + }) + .always(function() { + $body.removeClass('search-loading'); + }), 1000); + } + + function closeSearch() { + $body.removeClass('with-search'); + $bookSearchResults.removeClass('open'); + } + + function launchSearchFromQueryString() { + var q = getParameterByName('q'); + if (q && q.length > 0) { + // Update search input + $searchInput.val(q); + + // Launch search + launchSearch(q); + } + } + + function bindSearch() { + // Bind DOM + $searchInput = $('#book-search-input input'); + $bookSearchResults = $('#book-search-results'); + $searchList = $bookSearchResults.find('.search-results-list'); + $searchTitle = $bookSearchResults.find('.search-results-title'); + $searchResultsCount = $searchTitle.find('.search-results-count'); + $searchQuery = $searchTitle.find('.search-query'); + + // Launch query based on input content + function handleUpdate() { + var q = $searchInput.val(); + + if (q.length == 0) { + closeSearch(); + } + else { + launchSearch(q); + } + } + + // Detect true content change in search input + // Workaround for IE < 9 + var propertyChangeUnbound = false; + $searchInput.on('propertychange', function(e) { + if (e.originalEvent.propertyName == 'value') { + handleUpdate(); + } + }); + + // HTML5 (IE9 & others) + $searchInput.on('input', function(e) { + // Unbind propertychange event for IE9+ + if (!propertyChangeUnbound) { + $(this).unbind('propertychange'); + propertyChangeUnbound = true; + } + + handleUpdate(); + }); + + // Push to history on blur + $searchInput.on('blur', function(e) { + // Update history state + if (usePushState) { + var uri = updateQueryString('q', $(this).val()); + history.pushState({ path: uri }, null, uri); + } + }); + } + + gitbook.events.on('page.change', function() { + bindSearch(); + closeSearch(); + + // Launch search based on query parameter + if (gitbook.search.isInitialized()) { + launchSearchFromQueryString(); + } + }); + + gitbook.events.on('search.ready', function() { + bindSearch(); + + // Launch search from query param at start + launchSearchFromQueryString(); + }); + + function getParameterByName(name) { + var url = window.location.href; + name = name.replace(/[\[\]]/g, '\\$&'); + var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)', 'i'), + results = regex.exec(url); + if (!results) return null; + if (!results[2]) return ''; + return decodeURIComponent(results[2].replace(/\+/g, ' ')); + } + + function updateQueryString(key, value) { + value = encodeURIComponent(value); + + var url = window.location.href; + var re = new RegExp('([?&])' + key + '=.*?(&|#|$)(.*)', 'gi'), + hash; + + if (re.test(url)) { + if (typeof value !== 'undefined' && value !== null) + return url.replace(re, '$1' + key + '=' + value + '$2$3'); + else { + hash = url.split('#'); + url = hash[0].replace(re, '$1$3').replace(/(&|\?)$/, ''); + if (typeof hash[1] !== 'undefined' && hash[1] !== null) + url += '#' + hash[1]; + return url; + } + } + else { + if (typeof value !== 'undefined' && value !== null) { + var separator = url.indexOf('?') !== -1 ? '&' : '?'; + hash = url.split('#'); + url = hash[0] + separator + key + '=' + value; + if (typeof hash[1] !== 'undefined' && hash[1] !== null) + url += '#' + hash[1]; + return url; + } + else + return url; + } + } +}); diff --git a/docs/book/gitbook/gitbook-plugin-sharing/buttons.js b/docs/book/gitbook/gitbook-plugin-sharing/buttons.js new file mode 100644 index 000000000..709a4e4c0 --- /dev/null +++ b/docs/book/gitbook/gitbook-plugin-sharing/buttons.js @@ -0,0 +1,90 @@ +require(['gitbook', 'jquery'], function(gitbook, $) { + var SITES = { + 'facebook': { + 'label': 'Facebook', + 'icon': 'fa fa-facebook', + 'onClick': function(e) { + e.preventDefault(); + window.open('http://www.facebook.com/sharer/sharer.php?s=100&p[url]='+encodeURIComponent(location.href)); + } + }, + 'twitter': { + 'label': 'Twitter', + 'icon': 'fa fa-twitter', + 'onClick': function(e) { + e.preventDefault(); + window.open('http://twitter.com/home?status='+encodeURIComponent(document.title+' '+location.href)); + } + }, + 'google': { + 'label': 'Google+', + 'icon': 'fa fa-google-plus', + 'onClick': function(e) { + e.preventDefault(); + window.open('https://plus.google.com/share?url='+encodeURIComponent(location.href)); + } + }, + 'weibo': { + 'label': 'Weibo', + 'icon': 'fa fa-weibo', + 'onClick': function(e) { + e.preventDefault(); + window.open('http://service.weibo.com/share/share.php?content=utf-8&url='+encodeURIComponent(location.href)+'&title='+encodeURIComponent(document.title)); + } + }, + 'instapaper': { + 'label': 'Instapaper', + 'icon': 'fa fa-instapaper', + 'onClick': function(e) { + e.preventDefault(); + window.open('http://www.instapaper.com/text?u='+encodeURIComponent(location.href)); + } + }, + 'vk': { + 'label': 'VK', + 'icon': 'fa fa-vk', + 'onClick': function(e) { + e.preventDefault(); + window.open('http://vkontakte.ru/share.php?url='+encodeURIComponent(location.href)); + } + } + }; + + + + gitbook.events.bind('start', function(e, config) { + var opts = config.sharing; + + // Create dropdown menu + var menu = $.map(opts.all, function(id) { + var site = SITES[id]; + + return { + text: site.label, + onClick: site.onClick + }; + }); + + // Create main button with dropdown + if (menu.length > 0) { + gitbook.toolbar.createButton({ + icon: 'fa fa-share-alt', + label: 'Share', + position: 'right', + dropdown: [menu] + }); + } + + // Direct actions to share + $.each(SITES, function(sideId, site) { + if (!opts[sideId]) return; + + gitbook.toolbar.createButton({ + icon: site.icon, + label: site.text, + position: 'right', + onClick: site.onClick + }); + }); + }); +}); diff --git a/docs/book/gitbook/gitbook.js b/docs/book/gitbook/gitbook.js new file mode 100644 index 000000000..10000c790 --- /dev/null +++ b/docs/book/gitbook/gitbook.js @@ -0,0 +1,4 @@ +!function e(t,n,r){function o(s,a){if(!n[s]){if(!t[s]){var u="function"==typeof require&&require;if(!a&&u)return u(s,!0);if(i)return i(s,!0);var c=new Error("Cannot find module '"+s+"'");throw c.code="MODULE_NOT_FOUND",c}var l=n[s]={exports:{}};t[s][0].call(l.exports,function(e){var n=t[s][1][e];return o(n?n:e)},l,l.exports,e,t,n,r)}return n[s].exports}for(var i="function"==typeof require&&require,s=0;s0&&t-1 in e)}function o(e,t,n){return de.isFunction(t)?de.grep(e,function(e,r){return!!t.call(e,r,e)!==n}):t.nodeType?de.grep(e,function(e){return e===t!==n}):"string"!=typeof t?de.grep(e,function(e){return se.call(t,e)>-1!==n}):je.test(t)?de.filter(t,e,n):(t=de.filter(t,e),de.grep(e,function(e){return se.call(t,e)>-1!==n&&1===e.nodeType}))}function i(e,t){for(;(e=e[t])&&1!==e.nodeType;);return e}function s(e){var t={};return de.each(e.match(qe)||[],function(e,n){t[n]=!0}),t}function a(e){return e}function u(e){throw e}function c(e,t,n){var r;try{e&&de.isFunction(r=e.promise)?r.call(e).done(t).fail(n):e&&de.isFunction(r=e.then)?r.call(e,t,n):t.call(void 0,e)}catch(e){n.call(void 0,e)}}function l(){te.removeEventListener("DOMContentLoaded",l),e.removeEventListener("load",l),de.ready()}function f(){this.expando=de.expando+f.uid++}function p(e){return"true"===e||"false"!==e&&("null"===e?null:e===+e+""?+e:Ie.test(e)?JSON.parse(e):e)}function h(e,t,n){var r;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(Pe,"-$&").toLowerCase(),n=e.getAttribute(r),"string"==typeof n){try{n=p(n)}catch(e){}Re.set(e,t,n)}else n=void 0;return n}function d(e,t,n,r){var o,i=1,s=20,a=r?function(){return r.cur()}:function(){return de.css(e,t,"")},u=a(),c=n&&n[3]||(de.cssNumber[t]?"":"px"),l=(de.cssNumber[t]||"px"!==c&&+u)&&$e.exec(de.css(e,t));if(l&&l[3]!==c){c=c||l[3],n=n||[],l=+u||1;do i=i||".5",l/=i,de.style(e,t,l+c);while(i!==(i=a()/u)&&1!==i&&--s)}return n&&(l=+l||+u||0,o=n[1]?l+(n[1]+1)*n[2]:+n[2],r&&(r.unit=c,r.start=l,r.end=o)),o}function g(e){var t,n=e.ownerDocument,r=e.nodeName,o=Ue[r];return o?o:(t=n.body.appendChild(n.createElement(r)),o=de.css(t,"display"),t.parentNode.removeChild(t),"none"===o&&(o="block"),Ue[r]=o,o)}function m(e,t){for(var n,r,o=[],i=0,s=e.length;i-1)o&&o.push(i);else if(c=de.contains(i.ownerDocument,i),s=v(f.appendChild(i),"script"),c&&y(s),n)for(l=0;i=s[l++];)Ve.test(i.type||"")&&n.push(i);return f}function b(){return!0}function w(){return!1}function T(){try{return te.activeElement}catch(e){}}function C(e,t,n,r,o,i){var s,a;if("object"==typeof t){"string"!=typeof n&&(r=r||n,n=void 0);for(a in t)C(e,a,n,r,t[a],i);return e}if(null==r&&null==o?(o=n,r=n=void 0):null==o&&("string"==typeof n?(o=r,r=void 0):(o=r,r=n,n=void 0)),o===!1)o=w;else if(!o)return e;return 1===i&&(s=o,o=function(e){return de().off(e),s.apply(this,arguments)},o.guid=s.guid||(s.guid=de.guid++)),e.each(function(){de.event.add(this,t,o,r,n)})}function j(e,t){return de.nodeName(e,"table")&&de.nodeName(11!==t.nodeType?t:t.firstChild,"tr")?e.getElementsByTagName("tbody")[0]||e:e}function k(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function E(e){var t=rt.exec(e.type);return t?e.type=t[1]:e.removeAttribute("type"),e}function S(e,t){var n,r,o,i,s,a,u,c;if(1===t.nodeType){if(Fe.hasData(e)&&(i=Fe.access(e),s=Fe.set(t,i),c=i.events)){delete s.handle,s.events={};for(o in c)for(n=0,r=c[o].length;n1&&"string"==typeof d&&!pe.checkClone&&nt.test(d))return e.each(function(n){var i=e.eq(n);g&&(t[0]=d.call(this,n,i.html())),A(i,t,r,o)});if(p&&(i=x(t,e[0].ownerDocument,!1,e,o),s=i.firstChild,1===i.childNodes.length&&(i=s),s||o)){for(a=de.map(v(i,"script"),k),u=a.length;f=0&&nC.cacheLength&&delete e[t.shift()],e[n+" "]=r}var t=[];return e}function r(e){return e[$]=!0,e}function o(e){var t=L.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function i(e,t){for(var n=e.split("|"),r=n.length;r--;)C.attrHandle[n[r]]=t}function s(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)for(;n=n.nextSibling;)if(n===t)return-1;return e?1:-1}function a(e){return function(t){var n=t.nodeName.toLowerCase();return"input"===n&&t.type===e}}function u(e){return function(t){var n=t.nodeName.toLowerCase();return("input"===n||"button"===n)&&t.type===e}}function c(e){return function(t){return"form"in t?t.parentNode&&t.disabled===!1?"label"in t?"label"in t.parentNode?t.parentNode.disabled===e:t.disabled===e:t.isDisabled===e||t.isDisabled!==!e&&je(t)===e:t.disabled===e:"label"in t&&t.disabled===e}}function l(e){return r(function(t){return t=+t,r(function(n,r){for(var o,i=e([],n.length,t),s=i.length;s--;)n[o=i[s]]&&(n[o]=!(r[o]=n[o]))})})}function f(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}function p(){}function h(e){for(var t=0,n=e.length,r="";t1?function(t,n,r){for(var o=e.length;o--;)if(!e[o](t,n,r))return!1;return!0}:e[0]}function m(e,n,r){for(var o=0,i=n.length;o-1&&(r[c]=!(s[c]=f))}}else x=v(x===s?x.splice(d,x.length):x),i?i(null,s,x,u):K.apply(s,x)})}function x(e){for(var t,n,r,o=e.length,i=C.relative[e[0].type],s=i||C.relative[" "],a=i?1:0,u=d(function(e){return e===t},s,!0),c=d(function(e){return ee(t,e)>-1},s,!0),l=[function(e,n,r){var o=!i&&(r||n!==A)||((t=n).nodeType?u(e,n,r):c(e,n,r));return t=null,o}];a1&&g(l),a>1&&h(e.slice(0,a-1).concat({value:" "===e[a-2].type?"*":""})).replace(ae,"$1"),n,a0,i=e.length>0,s=function(r,s,a,u,c){var l,f,p,h=0,d="0",g=r&&[],m=[],y=A,x=r||i&&C.find.TAG("*",c),b=B+=null==y?1:Math.random()||.1,w=x.length;for(c&&(A=s===L||s||c);d!==w&&null!=(l=x[d]);d++){if(i&&l){for(f=0,s||l.ownerDocument===L||(O(l),a=!F);p=e[f++];)if(p(l,s||L,a)){u.push(l);break}c&&(B=b)}o&&((l=!p&&l)&&h--,r&&g.push(l))}if(h+=d,o&&d!==h){for(f=0;p=n[f++];)p(g,m,s,a);if(r){if(h>0)for(;d--;)g[d]||m[d]||(m[d]=Q.call(u));m=v(m)}K.apply(u,m),c&&!r&&m.length>0&&h+n.length>1&&t.uniqueSort(u)}return c&&(B=b,A=y),g};return o?r(s):s}var w,T,C,j,k,E,S,N,A,q,D,O,L,H,F,R,I,P,M,$="sizzle"+1*new Date,W=e.document,B=0,_=0,U=n(),z=n(),X=n(),V=function(e,t){return e===t&&(D=!0),0},G={}.hasOwnProperty,Y=[],Q=Y.pop,J=Y.push,K=Y.push,Z=Y.slice,ee=function(e,t){for(var n=0,r=e.length;n+~]|"+ne+")"+ne+"*"),le=new RegExp("="+ne+"*([^\\]'\"]*?)"+ne+"*\\]","g"),fe=new RegExp(ie),pe=new RegExp("^"+re+"$"),he={ID:new RegExp("^#("+re+")"),CLASS:new RegExp("^\\.("+re+")"),TAG:new RegExp("^("+re+"|[*])"),ATTR:new RegExp("^"+oe),PSEUDO:new RegExp("^"+ie),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+ne+"*(even|odd|(([+-]|)(\\d*)n|)"+ne+"*(?:([+-]|)"+ne+"*(\\d+)|))"+ne+"*\\)|)","i"),bool:new RegExp("^(?:"+te+")$","i"),needsContext:new RegExp("^"+ne+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+ne+"*((?:-\\d)?\\d*)"+ne+"*\\)|)(?=[^-]|$)","i")},de=/^(?:input|select|textarea|button)$/i,ge=/^h\d$/i,me=/^[^{]+\{\s*\[native \w/,ve=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ye=/[+~]/,xe=new RegExp("\\\\([\\da-f]{1,6}"+ne+"?|("+ne+")|.)","ig"),be=function(e,t,n){var r="0x"+t-65536;return r!==r||n?t:r<0?String.fromCharCode(r+65536):String.fromCharCode(r>>10|55296,1023&r|56320)},we=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,Te=function(e,t){return t?"\0"===e?"�":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},Ce=function(){O()},je=d(function(e){return e.disabled===!0&&("form"in e||"label"in e)},{dir:"parentNode",next:"legend"});try{K.apply(Y=Z.call(W.childNodes),W.childNodes),Y[W.childNodes.length].nodeType}catch(e){K={apply:Y.length?function(e,t){J.apply(e,Z.call(t))}:function(e,t){for(var n=e.length,r=0;e[n++]=t[r++];);e.length=n-1}}}T=t.support={},k=t.isXML=function(e){var t=e&&(e.ownerDocument||e).documentElement;return!!t&&"HTML"!==t.nodeName},O=t.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:W;return r!==L&&9===r.nodeType&&r.documentElement?(L=r,H=L.documentElement,F=!k(L),W!==L&&(n=L.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",Ce,!1):n.attachEvent&&n.attachEvent("onunload",Ce)),T.attributes=o(function(e){return e.className="i",!e.getAttribute("className")}),T.getElementsByTagName=o(function(e){return e.appendChild(L.createComment("")),!e.getElementsByTagName("*").length}),T.getElementsByClassName=me.test(L.getElementsByClassName),T.getById=o(function(e){return H.appendChild(e).id=$,!L.getElementsByName||!L.getElementsByName($).length}),T.getById?(C.filter.ID=function(e){var t=e.replace(xe,be);return function(e){return e.getAttribute("id")===t}},C.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&F){var n=t.getElementById(e);return n?[n]:[]}}):(C.filter.ID=function(e){var t=e.replace(xe,be);return function(e){var n="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return n&&n.value===t}},C.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&F){var n,r,o,i=t.getElementById(e);if(i){if(n=i.getAttributeNode("id"),n&&n.value===e)return[i];for(o=t.getElementsByName(e),r=0;i=o[r++];)if(n=i.getAttributeNode("id"),n&&n.value===e)return[i]}return[]}}),C.find.TAG=T.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):T.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],o=0,i=t.getElementsByTagName(e);if("*"===e){for(;n=i[o++];)1===n.nodeType&&r.push(n);return r}return i},C.find.CLASS=T.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&F)return t.getElementsByClassName(e)},I=[],R=[],(T.qsa=me.test(L.querySelectorAll))&&(o(function(e){H.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&R.push("[*^$]="+ne+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||R.push("\\["+ne+"*(?:value|"+te+")"),e.querySelectorAll("[id~="+$+"-]").length||R.push("~="),e.querySelectorAll(":checked").length||R.push(":checked"),e.querySelectorAll("a#"+$+"+*").length||R.push(".#.+[+~]")}),o(function(e){e.innerHTML="";var t=L.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&R.push("name"+ne+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&R.push(":enabled",":disabled"),H.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&R.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),R.push(",.*:")})),(T.matchesSelector=me.test(P=H.matches||H.webkitMatchesSelector||H.mozMatchesSelector||H.oMatchesSelector||H.msMatchesSelector))&&o(function(e){T.disconnectedMatch=P.call(e,"*"),P.call(e,"[s!='']:x"),I.push("!=",ie)}),R=R.length&&new RegExp(R.join("|")),I=I.length&&new RegExp(I.join("|")),t=me.test(H.compareDocumentPosition),M=t||me.test(H.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)for(;t=t.parentNode;)if(t===e)return!0;return!1},V=t?function(e,t){if(e===t)return D=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n?n:(n=(e.ownerDocument||e)===(t.ownerDocument||t)?e.compareDocumentPosition(t):1,1&n||!T.sortDetached&&t.compareDocumentPosition(e)===n?e===L||e.ownerDocument===W&&M(W,e)?-1:t===L||t.ownerDocument===W&&M(W,t)?1:q?ee(q,e)-ee(q,t):0:4&n?-1:1)}:function(e,t){if(e===t)return D=!0,0;var n,r=0,o=e.parentNode,i=t.parentNode,a=[e],u=[t];if(!o||!i)return e===L?-1:t===L?1:o?-1:i?1:q?ee(q,e)-ee(q,t):0;if(o===i)return s(e,t);for(n=e;n=n.parentNode;)a.unshift(n);for(n=t;n=n.parentNode;)u.unshift(n);for(;a[r]===u[r];)r++;return r?s(a[r],u[r]):a[r]===W?-1:u[r]===W?1:0},L):L},t.matches=function(e,n){return t(e,null,null,n)},t.matchesSelector=function(e,n){if((e.ownerDocument||e)!==L&&O(e),n=n.replace(le,"='$1']"),T.matchesSelector&&F&&!X[n+" "]&&(!I||!I.test(n))&&(!R||!R.test(n)))try{var r=P.call(e,n);if(r||T.disconnectedMatch||e.document&&11!==e.document.nodeType)return r}catch(e){}return t(n,L,null,[e]).length>0},t.contains=function(e,t){return(e.ownerDocument||e)!==L&&O(e),M(e,t)},t.attr=function(e,t){(e.ownerDocument||e)!==L&&O(e);var n=C.attrHandle[t.toLowerCase()],r=n&&G.call(C.attrHandle,t.toLowerCase())?n(e,t,!F):void 0;return void 0!==r?r:T.attributes||!F?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},t.escape=function(e){return(e+"").replace(we,Te)},t.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},t.uniqueSort=function(e){var t,n=[],r=0,o=0;if(D=!T.detectDuplicates,q=!T.sortStable&&e.slice(0),e.sort(V),D){for(;t=e[o++];)t===e[o]&&(r=n.push(o));for(;r--;)e.splice(n[r],1)}return q=null,e},j=t.getText=function(e){var t,n="",r=0,o=e.nodeType;if(o){if(1===o||9===o||11===o){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=j(e)}else if(3===o||4===o)return e.nodeValue}else for(;t=e[r++];)n+=j(t);return n},C=t.selectors={cacheLength:50,createPseudo:r,match:he,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(xe,be),e[3]=(e[3]||e[4]||e[5]||"").replace(xe,be),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||t.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&t.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return he.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&fe.test(n)&&(t=E(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(xe,be).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=U[e+" "];return t||(t=new RegExp("(^|"+ne+")"+e+"("+ne+"|$)"))&&U(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(e,n,r){return function(o){var i=t.attr(o,e);return null==i?"!="===n:!n||(i+="","="===n?i===r:"!="===n?i!==r:"^="===n?r&&0===i.indexOf(r):"*="===n?r&&i.indexOf(r)>-1:"$="===n?r&&i.slice(-r.length)===r:"~="===n?(" "+i.replace(se," ")+" ").indexOf(r)>-1:"|="===n&&(i===r||i.slice(0,r.length+1)===r+"-"))}},CHILD:function(e,t,n,r,o){var i="nth"!==e.slice(0,3),s="last"!==e.slice(-4),a="of-type"===t;return 1===r&&0===o?function(e){return!!e.parentNode}:function(t,n,u){var c,l,f,p,h,d,g=i!==s?"nextSibling":"previousSibling",m=t.parentNode,v=a&&t.nodeName.toLowerCase(),y=!u&&!a,x=!1;if(m){if(i){for(;g;){for(p=t;p=p[g];)if(a?p.nodeName.toLowerCase()===v:1===p.nodeType)return!1;d=g="only"===e&&!d&&"nextSibling"}return!0}if(d=[s?m.firstChild:m.lastChild],s&&y){for(p=m,f=p[$]||(p[$]={}),l=f[p.uniqueID]||(f[p.uniqueID]={}),c=l[e]||[],h=c[0]===B&&c[1],x=h&&c[2],p=h&&m.childNodes[h];p=++h&&p&&p[g]||(x=h=0)||d.pop();)if(1===p.nodeType&&++x&&p===t){l[e]=[B,h,x];break}}else if(y&&(p=t,f=p[$]||(p[$]={}),l=f[p.uniqueID]||(f[p.uniqueID]={}),c=l[e]||[],h=c[0]===B&&c[1],x=h),x===!1)for(;(p=++h&&p&&p[g]||(x=h=0)||d.pop())&&((a?p.nodeName.toLowerCase()!==v:1!==p.nodeType)||!++x||(y&&(f=p[$]||(p[$]={}),l=f[p.uniqueID]||(f[p.uniqueID]={}),l[e]=[B,x]),p!==t)););return x-=o,x===r||x%r===0&&x/r>=0}}},PSEUDO:function(e,n){var o,i=C.pseudos[e]||C.setFilters[e.toLowerCase()]||t.error("unsupported pseudo: "+e);return i[$]?i(n):i.length>1?(o=[e,e,"",n],C.setFilters.hasOwnProperty(e.toLowerCase())?r(function(e,t){for(var r,o=i(e,n),s=o.length;s--;)r=ee(e,o[s]),e[r]=!(t[r]=o[s])}):function(e){return i(e,0,o)}):i}},pseudos:{not:r(function(e){var t=[],n=[],o=S(e.replace(ae,"$1"));return o[$]?r(function(e,t,n,r){for(var i,s=o(e,null,r,[]),a=e.length;a--;)(i=s[a])&&(e[a]=!(t[a]=i))}):function(e,r,i){return t[0]=e,o(t,null,i,n),t[0]=null,!n.pop()}}),has:r(function(e){return function(n){ +return t(e,n).length>0}}),contains:r(function(e){return e=e.replace(xe,be),function(t){return(t.textContent||t.innerText||j(t)).indexOf(e)>-1}}),lang:r(function(e){return pe.test(e||"")||t.error("unsupported lang: "+e),e=e.replace(xe,be).toLowerCase(),function(t){var n;do if(n=F?t.lang:t.getAttribute("xml:lang")||t.getAttribute("lang"))return n=n.toLowerCase(),n===e||0===n.indexOf(e+"-");while((t=t.parentNode)&&1===t.nodeType);return!1}}),target:function(t){var n=e.location&&e.location.hash;return n&&n.slice(1)===t.id},root:function(e){return e===H},focus:function(e){return e===L.activeElement&&(!L.hasFocus||L.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:c(!1),disabled:c(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,e.selected===!0},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!C.pseudos.empty(e)},header:function(e){return ge.test(e.nodeName)},input:function(e){return de.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:l(function(){return[0]}),last:l(function(e,t){return[t-1]}),eq:l(function(e,t,n){return[n<0?n+t:n]}),even:l(function(e,t){for(var n=0;n=0;)e.push(r);return e}),gt:l(function(e,t,n){for(var r=n<0?n+t:n;++r2&&"ID"===(s=i[0]).type&&9===t.nodeType&&F&&C.relative[i[1].type]){if(t=(C.find.ID(s.matches[0].replace(xe,be),t)||[])[0],!t)return n;c&&(t=t.parentNode),e=e.slice(i.shift().value.length)}for(o=he.needsContext.test(e)?0:i.length;o--&&(s=i[o],!C.relative[a=s.type]);)if((u=C.find[a])&&(r=u(s.matches[0].replace(xe,be),ye.test(i[0].type)&&f(t.parentNode)||t))){if(i.splice(o,1),e=r.length&&h(i),!e)return K.apply(n,r),n;break}}return(c||S(e,l))(r,t,!F,n,!t||ye.test(e)&&f(t.parentNode)||t),n},T.sortStable=$.split("").sort(V).join("")===$,T.detectDuplicates=!!D,O(),T.sortDetached=o(function(e){return 1&e.compareDocumentPosition(L.createElement("fieldset"))}),o(function(e){return e.innerHTML="","#"===e.firstChild.getAttribute("href")})||i("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),T.attributes&&o(function(e){return e.innerHTML="",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||i("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),o(function(e){return null==e.getAttribute("disabled")})||i(te,function(e,t,n){var r;if(!n)return e[t]===!0?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),t}(e);de.find=xe,de.expr=xe.selectors,de.expr[":"]=de.expr.pseudos,de.uniqueSort=de.unique=xe.uniqueSort,de.text=xe.getText,de.isXMLDoc=xe.isXML,de.contains=xe.contains,de.escapeSelector=xe.escape;var be=function(e,t,n){for(var r=[],o=void 0!==n;(e=e[t])&&9!==e.nodeType;)if(1===e.nodeType){if(o&&de(e).is(n))break;r.push(e)}return r},we=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},Te=de.expr.match.needsContext,Ce=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i,je=/^.[^:#\[\.,]*$/;de.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?de.find.matchesSelector(r,e)?[r]:[]:de.find.matches(e,de.grep(t,function(e){return 1===e.nodeType}))},de.fn.extend({find:function(e){var t,n,r=this.length,o=this;if("string"!=typeof e)return this.pushStack(de(e).filter(function(){for(t=0;t1?de.uniqueSort(n):n},filter:function(e){return this.pushStack(o(this,e||[],!1))},not:function(e){return this.pushStack(o(this,e||[],!0))},is:function(e){return!!o(this,"string"==typeof e&&Te.test(e)?de(e):e||[],!1).length}});var ke,Ee=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,Se=de.fn.init=function(e,t,n){var r,o;if(!e)return this;if(n=n||ke,"string"==typeof e){if(r="<"===e[0]&&">"===e[e.length-1]&&e.length>=3?[null,e,null]:Ee.exec(e),!r||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof de?t[0]:t,de.merge(this,de.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:te,!0)),Ce.test(r[1])&&de.isPlainObject(t))for(r in t)de.isFunction(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return o=te.getElementById(r[2]),o&&(this[0]=o,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):de.isFunction(e)?void 0!==n.ready?n.ready(e):e(de):de.makeArray(e,this)};Se.prototype=de.fn,ke=de(te);var Ne=/^(?:parents|prev(?:Until|All))/,Ae={children:!0,contents:!0,next:!0,prev:!0};de.fn.extend({has:function(e){var t=de(e,this),n=t.length;return this.filter(function(){for(var e=0;e-1:1===n.nodeType&&de.find.matchesSelector(n,e))){i.push(n);break}return this.pushStack(i.length>1?de.uniqueSort(i):i)},index:function(e){return e?"string"==typeof e?se.call(de(e),this[0]):se.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(de.uniqueSort(de.merge(this.get(),de(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),de.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return be(e,"parentNode")},parentsUntil:function(e,t,n){return be(e,"parentNode",n)},next:function(e){return i(e,"nextSibling")},prev:function(e){return i(e,"previousSibling")},nextAll:function(e){return be(e,"nextSibling")},prevAll:function(e){return be(e,"previousSibling")},nextUntil:function(e,t,n){return be(e,"nextSibling",n)},prevUntil:function(e,t,n){return be(e,"previousSibling",n)},siblings:function(e){return we((e.parentNode||{}).firstChild,e)},children:function(e){return we(e.firstChild)},contents:function(e){return e.contentDocument||de.merge([],e.childNodes)}},function(e,t){de.fn[e]=function(n,r){var o=de.map(this,t,n);return"Until"!==e.slice(-5)&&(r=n),r&&"string"==typeof r&&(o=de.filter(r,o)),this.length>1&&(Ae[e]||de.uniqueSort(o),Ne.test(e)&&o.reverse()),this.pushStack(o)}});var qe=/[^\x20\t\r\n\f]+/g;de.Callbacks=function(e){e="string"==typeof e?s(e):de.extend({},e);var t,n,r,o,i=[],a=[],u=-1,c=function(){for(o=e.once,r=t=!0;a.length;u=-1)for(n=a.shift();++u-1;)i.splice(n,1),n<=u&&u--}),this},has:function(e){return e?de.inArray(e,i)>-1:i.length>0},empty:function(){return i&&(i=[]),this},disable:function(){return o=a=[],i=n="",this},disabled:function(){return!i},lock:function(){return o=a=[],n||t||(i=n=""),this},locked:function(){return!!o},fireWith:function(e,n){return o||(n=n||[],n=[e,n.slice?n.slice():n],a.push(n),t||c()),this},fire:function(){return l.fireWith(this,arguments),this},fired:function(){return!!r}};return l},de.extend({Deferred:function(t){var n=[["notify","progress",de.Callbacks("memory"),de.Callbacks("memory"),2],["resolve","done",de.Callbacks("once memory"),de.Callbacks("once memory"),0,"resolved"],["reject","fail",de.Callbacks("once memory"),de.Callbacks("once memory"),1,"rejected"]],r="pending",o={state:function(){return r},always:function(){return i.done(arguments).fail(arguments),this},catch:function(e){return o.then(null,e)},pipe:function(){var e=arguments;return de.Deferred(function(t){de.each(n,function(n,r){var o=de.isFunction(e[r[4]])&&e[r[4]];i[r[1]](function(){var e=o&&o.apply(this,arguments);e&&de.isFunction(e.promise)?e.promise().progress(t.notify).done(t.resolve).fail(t.reject):t[r[0]+"With"](this,o?[e]:arguments)})}),e=null}).promise()},then:function(t,r,o){function i(t,n,r,o){return function(){var c=this,l=arguments,f=function(){var e,f;if(!(t=s&&(r!==u&&(c=void 0,l=[e]),n.rejectWith(c,l))}};t?p():(de.Deferred.getStackHook&&(p.stackTrace=de.Deferred.getStackHook()),e.setTimeout(p))}}var s=0;return de.Deferred(function(e){n[0][3].add(i(0,e,de.isFunction(o)?o:a,e.notifyWith)),n[1][3].add(i(0,e,de.isFunction(t)?t:a)),n[2][3].add(i(0,e,de.isFunction(r)?r:u))}).promise()},promise:function(e){return null!=e?de.extend(e,o):o}},i={};return de.each(n,function(e,t){var s=t[2],a=t[5];o[t[1]]=s.add,a&&s.add(function(){r=a},n[3-e][2].disable,n[0][2].lock),s.add(t[3].fire),i[t[0]]=function(){return i[t[0]+"With"](this===i?void 0:this,arguments),this},i[t[0]+"With"]=s.fireWith}),o.promise(i),t&&t.call(i,i),i},when:function(e){var t=arguments.length,n=t,r=Array(n),o=re.call(arguments),i=de.Deferred(),s=function(e){return function(n){r[e]=this,o[e]=arguments.length>1?re.call(arguments):n,--t||i.resolveWith(r,o)}};if(t<=1&&(c(e,i.done(s(n)).resolve,i.reject),"pending"===i.state()||de.isFunction(o[n]&&o[n].then)))return i.then();for(;n--;)c(o[n],s(n),i.reject);return i.promise()}});var De=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;de.Deferred.exceptionHook=function(t,n){e.console&&e.console.warn&&t&&De.test(t.name)&&e.console.warn("jQuery.Deferred exception: "+t.message,t.stack,n)},de.readyException=function(t){e.setTimeout(function(){throw t})};var Oe=de.Deferred();de.fn.ready=function(e){return Oe.then(e).catch(function(e){de.readyException(e)}),this},de.extend({isReady:!1,readyWait:1,holdReady:function(e){e?de.readyWait++:de.ready(!0)},ready:function(e){(e===!0?--de.readyWait:de.isReady)||(de.isReady=!0,e!==!0&&--de.readyWait>0||Oe.resolveWith(te,[de]))}}),de.ready.then=Oe.then,"complete"===te.readyState||"loading"!==te.readyState&&!te.documentElement.doScroll?e.setTimeout(de.ready):(te.addEventListener("DOMContentLoaded",l),e.addEventListener("load",l));var Le=function(e,t,n,r,o,i,s){var a=0,u=e.length,c=null==n;if("object"===de.type(n)){o=!0;for(a in n)Le(e,t,a,n[a],!0,i,s)}else if(void 0!==r&&(o=!0,de.isFunction(r)||(s=!0),c&&(s?(t.call(e,r),t=null):(c=t,t=function(e,t,n){return c.call(de(e),n)})),t))for(;a1,null,!0)},removeData:function(e){return this.each(function(){Re.remove(this,e)})}}),de.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Fe.get(e,t),n&&(!r||de.isArray(n)?r=Fe.access(e,t,de.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=de.queue(e,t),r=n.length,o=n.shift(),i=de._queueHooks(e,t),s=function(){de.dequeue(e,t)};"inprogress"===o&&(o=n.shift(),r--),o&&("fx"===t&&n.unshift("inprogress"),delete i.stop,o.call(e,s,i)),!r&&i&&i.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Fe.get(e,n)||Fe.access(e,n,{empty:de.Callbacks("once memory").add(function(){Fe.remove(e,[t+"queue",n])})})}}),de.fn.extend({queue:function(e,t){var n=2;return"string"!=typeof e&&(t=e,e="fx",n--),arguments.length\x20\t\r\n\f]+)/i,Ve=/^$|\/(?:java|ecma)script/i,Ge={option:[1,""],thead:[1,"","
                  "],col:[2,"","
                  "],tr:[2,"","
                  "],td:[3,"","
                  "],_default:[0,"",""]};Ge.optgroup=Ge.option,Ge.tbody=Ge.tfoot=Ge.colgroup=Ge.caption=Ge.thead,Ge.th=Ge.td;var Ye=/<|&#?\w+;/;!function(){var e=te.createDocumentFragment(),t=e.appendChild(te.createElement("div")),n=te.createElement("input");n.setAttribute("type","radio"),n.setAttribute("checked","checked"),n.setAttribute("name","t"),t.appendChild(n),pe.checkClone=t.cloneNode(!0).cloneNode(!0).lastChild.checked,t.innerHTML="",pe.noCloneChecked=!!t.cloneNode(!0).lastChild.defaultValue}();var Qe=te.documentElement,Je=/^key/,Ke=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Ze=/^([^.]*)(?:\.(.+)|)/;de.event={global:{},add:function(e,t,n,r,o){var i,s,a,u,c,l,f,p,h,d,g,m=Fe.get(e);if(m)for(n.handler&&(i=n,n=i.handler,o=i.selector),o&&de.find.matchesSelector(Qe,o),n.guid||(n.guid=de.guid++),(u=m.events)||(u=m.events={}),(s=m.handle)||(s=m.handle=function(t){return"undefined"!=typeof de&&de.event.triggered!==t.type?de.event.dispatch.apply(e,arguments):void 0}),t=(t||"").match(qe)||[""],c=t.length;c--;)a=Ze.exec(t[c])||[],h=g=a[1],d=(a[2]||"").split(".").sort(),h&&(f=de.event.special[h]||{},h=(o?f.delegateType:f.bindType)||h,f=de.event.special[h]||{},l=de.extend({type:h,origType:g,data:r,handler:n,guid:n.guid,selector:o,needsContext:o&&de.expr.match.needsContext.test(o),namespace:d.join(".")},i),(p=u[h])||(p=u[h]=[],p.delegateCount=0,f.setup&&f.setup.call(e,r,d,s)!==!1||e.addEventListener&&e.addEventListener(h,s)),f.add&&(f.add.call(e,l),l.handler.guid||(l.handler.guid=n.guid)),o?p.splice(p.delegateCount++,0,l):p.push(l),de.event.global[h]=!0)},remove:function(e,t,n,r,o){var i,s,a,u,c,l,f,p,h,d,g,m=Fe.hasData(e)&&Fe.get(e);if(m&&(u=m.events)){for(t=(t||"").match(qe)||[""],c=t.length;c--;)if(a=Ze.exec(t[c])||[],h=g=a[1],d=(a[2]||"").split(".").sort(),h){for(f=de.event.special[h]||{},h=(r?f.delegateType:f.bindType)||h,p=u[h]||[],a=a[2]&&new RegExp("(^|\\.)"+d.join("\\.(?:.*\\.|)")+"(\\.|$)"),s=i=p.length;i--;)l=p[i],!o&&g!==l.origType||n&&n.guid!==l.guid||a&&!a.test(l.namespace)||r&&r!==l.selector&&("**"!==r||!l.selector)||(p.splice(i,1),l.selector&&p.delegateCount--,f.remove&&f.remove.call(e,l));s&&!p.length&&(f.teardown&&f.teardown.call(e,d,m.handle)!==!1||de.removeEvent(e,h,m.handle),delete u[h])}else for(h in u)de.event.remove(e,h+t[c],n,r,!0);de.isEmptyObject(u)&&Fe.remove(e,"handle events")}},dispatch:function(e){var t,n,r,o,i,s,a=de.event.fix(e),u=new Array(arguments.length),c=(Fe.get(this,"events")||{})[a.type]||[],l=de.event.special[a.type]||{};for(u[0]=a,t=1;t=1))for(;c!==this;c=c.parentNode||this)if(1===c.nodeType&&("click"!==e.type||c.disabled!==!0)){for(i=[],s={},n=0;n-1:de.find(o,this,null,[c]).length),s[o]&&i.push(r);i.length&&a.push({elem:c,handlers:i})}return c=this,u\x20\t\r\n\f]*)[^>]*)\/>/gi,tt=/\s*$/g;de.extend({htmlPrefilter:function(e){return e.replace(et,"<$1>")},clone:function(e,t,n){var r,o,i,s,a=e.cloneNode(!0),u=de.contains(e.ownerDocument,e);if(!(pe.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||de.isXMLDoc(e)))for(s=v(a),i=v(e),r=0,o=i.length;r0&&y(s,!u&&v(e,"script")),a},cleanData:function(e){for(var t,n,r,o=de.event.special,i=0;void 0!==(n=e[i]);i++)if(He(n)){if(t=n[Fe.expando]){if(t.events)for(r in t.events)o[r]?de.event.remove(n,r):de.removeEvent(n,r,t.handle);n[Fe.expando]=void 0}n[Re.expando]&&(n[Re.expando]=void 0)}}}),de.fn.extend({detach:function(e){return q(this,e,!0)},remove:function(e){return q(this,e)},text:function(e){return Le(this,function(e){return void 0===e?de.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return A(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=j(this,e);t.appendChild(e)}})},prepend:function(){return A(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=j(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return A(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return A(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(de.cleanData(v(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return de.clone(this,e,t)})},html:function(e){return Le(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!tt.test(e)&&!Ge[(Xe.exec(e)||["",""])[1].toLowerCase()]){e=de.htmlPrefilter(e);try{for(;n1)}}),de.Tween=I,I.prototype={constructor:I,init:function(e,t,n,r,o,i){this.elem=e,this.prop=n,this.easing=o||de.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=i||(de.cssNumber[n]?"":"px")},cur:function(){var e=I.propHooks[this.prop];return e&&e.get?e.get(this):I.propHooks._default.get(this)},run:function(e){var t,n=I.propHooks[this.prop];return this.options.duration?this.pos=t=de.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):I.propHooks._default.set(this),this}},I.prototype.init.prototype=I.prototype,I.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=de.css(e.elem,e.prop,""),t&&"auto"!==t?t:0)},set:function(e){de.fx.step[e.prop]?de.fx.step[e.prop](e):1!==e.elem.nodeType||null==e.elem.style[de.cssProps[e.prop]]&&!de.cssHooks[e.prop]?e.elem[e.prop]=e.now:de.style(e.elem,e.prop,e.now+e.unit)}}},I.propHooks.scrollTop=I.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},de.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},de.fx=I.prototype.init,de.fx.step={};var ht,dt,gt=/^(?:toggle|show|hide)$/,mt=/queueHooks$/;de.Animation=de.extend(U,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return d(n.elem,e,$e.exec(t),n),n}]},tweener:function(e,t){de.isFunction(e)?(t=e,e=["*"]):e=e.match(qe);for(var n,r=0,o=e.length;r1)},removeAttr:function(e){return this.each(function(){de.removeAttr(this,e)})}}),de.extend({attr:function(e,t,n){var r,o,i=e.nodeType;if(3!==i&&8!==i&&2!==i)return"undefined"==typeof e.getAttribute?de.prop(e,t,n):(1===i&&de.isXMLDoc(e)||(o=de.attrHooks[t.toLowerCase()]||(de.expr.match.bool.test(t)?vt:void 0)),void 0!==n?null===n?void de.removeAttr(e,t):o&&"set"in o&&void 0!==(r=o.set(e,n,t))?r:(e.setAttribute(t,n+""),n):o&&"get"in o&&null!==(r=o.get(e,t))?r:(r=de.find.attr(e,t),null==r?void 0:r))},attrHooks:{type:{set:function(e,t){if(!pe.radioValue&&"radio"===t&&de.nodeName(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,o=t&&t.match(qe);if(o&&1===e.nodeType)for(;n=o[r++];)e.removeAttribute(n)}}),vt={set:function(e,t,n){return t===!1?de.removeAttr(e,n):e.setAttribute(n,n),n}},de.each(de.expr.match.bool.source.match(/\w+/g),function(e,t){var n=yt[t]||de.find.attr;yt[t]=function(e,t,r){var o,i,s=t.toLowerCase();return r||(i=yt[s],yt[s]=o,o=null!=n(e,t,r)?s:null,yt[s]=i),o}});var xt=/^(?:input|select|textarea|button)$/i,bt=/^(?:a|area)$/i;de.fn.extend({prop:function(e,t){return Le(this,de.prop,e,t,arguments.length>1)},removeProp:function(e){return this.each(function(){delete this[de.propFix[e]||e]})}}),de.extend({prop:function(e,t,n){var r,o,i=e.nodeType;if(3!==i&&8!==i&&2!==i)return 1===i&&de.isXMLDoc(e)||(t=de.propFix[t]||t,o=de.propHooks[t]),void 0!==n?o&&"set"in o&&void 0!==(r=o.set(e,n,t))?r:e[t]=n:o&&"get"in o&&null!==(r=o.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=de.find.attr(e,"tabindex");return t?parseInt(t,10):xt.test(e.nodeName)||bt.test(e.nodeName)&&e.href?0:-1}}},propFix:{for:"htmlFor",class:"className"}}),pe.optSelected||(de.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),de.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){de.propFix[this.toLowerCase()]=this}),de.fn.extend({addClass:function(e){var t,n,r,o,i,s,a,u=0;if(de.isFunction(e))return this.each(function(t){de(this).addClass(e.call(this,t,X(this)))});if("string"==typeof e&&e)for(t=e.match(qe)||[];n=this[u++];)if(o=X(n),r=1===n.nodeType&&" "+z(o)+" "){for(s=0;i=t[s++];)r.indexOf(" "+i+" ")<0&&(r+=i+" ");a=z(r),o!==a&&n.setAttribute("class",a)}return this},removeClass:function(e){var t,n,r,o,i,s,a,u=0;if(de.isFunction(e))return this.each(function(t){de(this).removeClass(e.call(this,t,X(this)))});if(!arguments.length)return this.attr("class","");if("string"==typeof e&&e)for(t=e.match(qe)||[];n=this[u++];)if(o=X(n),r=1===n.nodeType&&" "+z(o)+" "){for(s=0;i=t[s++];)for(;r.indexOf(" "+i+" ")>-1;)r=r.replace(" "+i+" "," ");a=z(r),o!==a&&n.setAttribute("class",a)}return this},toggleClass:function(e,t){var n=typeof e;return"boolean"==typeof t&&"string"===n?t?this.addClass(e):this.removeClass(e):de.isFunction(e)?this.each(function(n){de(this).toggleClass(e.call(this,n,X(this),t),t)}):this.each(function(){var t,r,o,i;if("string"===n)for(r=0,o=de(this),i=e.match(qe)||[];t=i[r++];)o.hasClass(t)?o.removeClass(t):o.addClass(t);else void 0!==e&&"boolean"!==n||(t=X(this),t&&Fe.set(this,"__className__",t),this.setAttribute&&this.setAttribute("class",t||e===!1?"":Fe.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;for(t=" "+e+" ";n=this[r++];)if(1===n.nodeType&&(" "+z(X(n))+" ").indexOf(t)>-1)return!0;return!1}});var wt=/\r/g;de.fn.extend({val:function(e){var t,n,r,o=this[0];{if(arguments.length)return r=de.isFunction(e),this.each(function(n){var o;1===this.nodeType&&(o=r?e.call(this,n,de(this).val()):e,null==o?o="":"number"==typeof o?o+="":de.isArray(o)&&(o=de.map(o,function(e){return null==e?"":e+""})),t=de.valHooks[this.type]||de.valHooks[this.nodeName.toLowerCase()],t&&"set"in t&&void 0!==t.set(this,o,"value")||(this.value=o))});if(o)return t=de.valHooks[o.type]||de.valHooks[o.nodeName.toLowerCase()],t&&"get"in t&&void 0!==(n=t.get(o,"value"))?n:(n=o.value,"string"==typeof n?n.replace(wt,""):null==n?"":n)}}}),de.extend({valHooks:{option:{get:function(e){var t=de.find.attr(e,"value");return null!=t?t:z(de.text(e))}},select:{get:function(e){var t,n,r,o=e.options,i=e.selectedIndex,s="select-one"===e.type,a=s?null:[],u=s?i+1:o.length;for(r=i<0?u:s?i:0;r-1)&&(n=!0);return n||(e.selectedIndex=-1),i}}}}),de.each(["radio","checkbox"],function(){de.valHooks[this]={set:function(e,t){if(de.isArray(t))return e.checked=de.inArray(de(e).val(),t)>-1}},pe.checkOn||(de.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})});var Tt=/^(?:focusinfocus|focusoutblur)$/;de.extend(de.event,{trigger:function(t,n,r,o){var i,s,a,u,c,l,f,p=[r||te],h=ce.call(t,"type")?t.type:t,d=ce.call(t,"namespace")?t.namespace.split("."):[];if(s=a=r=r||te,3!==r.nodeType&&8!==r.nodeType&&!Tt.test(h+de.event.triggered)&&(h.indexOf(".")>-1&&(d=h.split("."),h=d.shift(),d.sort()),c=h.indexOf(":")<0&&"on"+h,t=t[de.expando]?t:new de.Event(h,"object"==typeof t&&t),t.isTrigger=o?2:3,t.namespace=d.join("."),t.rnamespace=t.namespace?new RegExp("(^|\\.)"+d.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,t.result=void 0,t.target||(t.target=r),n=null==n?[t]:de.makeArray(n,[t]),f=de.event.special[h]||{},o||!f.trigger||f.trigger.apply(r,n)!==!1)){if(!o&&!f.noBubble&&!de.isWindow(r)){for(u=f.delegateType||h,Tt.test(u+h)||(s=s.parentNode);s;s=s.parentNode)p.push(s),a=s;a===(r.ownerDocument||te)&&p.push(a.defaultView||a.parentWindow||e)}for(i=0;(s=p[i++])&&!t.isPropagationStopped();)t.type=i>1?u:f.bindType||h,l=(Fe.get(s,"events")||{})[t.type]&&Fe.get(s,"handle"),l&&l.apply(s,n),l=c&&s[c],l&&l.apply&&He(s)&&(t.result=l.apply(s,n),t.result===!1&&t.preventDefault());return t.type=h,o||t.isDefaultPrevented()||f._default&&f._default.apply(p.pop(),n)!==!1||!He(r)||c&&de.isFunction(r[h])&&!de.isWindow(r)&&(a=r[c],a&&(r[c]=null),de.event.triggered=h,r[h](),de.event.triggered=void 0,a&&(r[c]=a)),t.result}},simulate:function(e,t,n){var r=de.extend(new de.Event,n,{type:e,isSimulated:!0});de.event.trigger(r,null,t)}}),de.fn.extend({trigger:function(e,t){return this.each(function(){de.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return de.event.trigger(e,t,n,!0)}}),de.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,t){de.fn[t]=function(e,n){return arguments.length>0?this.on(t,null,e,n):this.trigger(t)}}),de.fn.extend({hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),pe.focusin="onfocusin"in e,pe.focusin||de.each({focus:"focusin",blur:"focusout"},function(e,t){var n=function(e){de.event.simulate(t,e.target,de.event.fix(e))};de.event.special[t]={setup:function(){var r=this.ownerDocument||this,o=Fe.access(r,t);o||r.addEventListener(e,n,!0),Fe.access(r,t,(o||0)+1)},teardown:function(){var r=this.ownerDocument||this,o=Fe.access(r,t)-1;o?Fe.access(r,t,o):(r.removeEventListener(e,n,!0),Fe.remove(r,t))}}});var Ct=e.location,jt=de.now(),kt=/\?/;de.parseXML=function(t){var n;if(!t||"string"!=typeof t)return null;try{n=(new e.DOMParser).parseFromString(t,"text/xml")}catch(e){n=void 0}return n&&!n.getElementsByTagName("parsererror").length||de.error("Invalid XML: "+t),n};var Et=/\[\]$/,St=/\r?\n/g,Nt=/^(?:submit|button|image|reset|file)$/i,At=/^(?:input|select|textarea|keygen)/i;de.param=function(e,t){var n,r=[],o=function(e,t){var n=de.isFunction(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(de.isArray(e)||e.jquery&&!de.isPlainObject(e))de.each(e,function(){o(this.name,this.value)});else for(n in e)V(n,e[n],t,o);return r.join("&")},de.fn.extend({serialize:function(){return de.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=de.prop(this,"elements");return e?de.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!de(this).is(":disabled")&&At.test(this.nodeName)&&!Nt.test(e)&&(this.checked||!ze.test(e))}).map(function(e,t){var n=de(this).val();return null==n?null:de.isArray(n)?de.map(n,function(e){return{name:t.name,value:e.replace(St,"\r\n")}}):{name:t.name,value:n.replace(St,"\r\n")}}).get()}});var qt=/%20/g,Dt=/#.*$/,Ot=/([?&])_=[^&]*/,Lt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Ht=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Ft=/^(?:GET|HEAD)$/,Rt=/^\/\//,It={},Pt={},Mt="*/".concat("*"),$t=te.createElement("a");$t.href=Ct.href,de.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Ct.href,type:"GET",isLocal:Ht.test(Ct.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Mt,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":de.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?Q(Q(e,de.ajaxSettings),t):Q(de.ajaxSettings,e)},ajaxPrefilter:G(It),ajaxTransport:G(Pt),ajax:function(t,n){function r(t,n,r,a){var c,p,h,b,w,T=n;l||(l=!0,u&&e.clearTimeout(u),o=void 0,s=a||"",C.readyState=t>0?4:0,c=t>=200&&t<300||304===t,r&&(b=J(d,C,r)),b=K(d,b,C,c),c?(d.ifModified&&(w=C.getResponseHeader("Last-Modified"),w&&(de.lastModified[i]=w),w=C.getResponseHeader("etag"),w&&(de.etag[i]=w)),204===t||"HEAD"===d.type?T="nocontent":304===t?T="notmodified":(T=b.state,p=b.data,h=b.error,c=!h)):(h=T,!t&&T||(T="error",t<0&&(t=0))),C.status=t,C.statusText=(n||T)+"",c?v.resolveWith(g,[p,T,C]):v.rejectWith(g,[C,T,h]),C.statusCode(x),x=void 0,f&&m.trigger(c?"ajaxSuccess":"ajaxError",[C,d,c?p:h]),y.fireWith(g,[C,T]),f&&(m.trigger("ajaxComplete",[C,d]),--de.active||de.event.trigger("ajaxStop")))}"object"==typeof t&&(n=t,t=void 0),n=n||{};var o,i,s,a,u,c,l,f,p,h,d=de.ajaxSetup({},n),g=d.context||d,m=d.context&&(g.nodeType||g.jquery)?de(g):de.event,v=de.Deferred(),y=de.Callbacks("once memory"),x=d.statusCode||{},b={},w={},T="canceled",C={readyState:0,getResponseHeader:function(e){var t;if(l){if(!a)for(a={};t=Lt.exec(s);)a[t[1].toLowerCase()]=t[2];t=a[e.toLowerCase()]}return null==t?null:t},getAllResponseHeaders:function(){return l?s:null},setRequestHeader:function(e,t){return null==l&&(e=w[e.toLowerCase()]=w[e.toLowerCase()]||e,b[e]=t),this},overrideMimeType:function(e){return null==l&&(d.mimeType=e),this},statusCode:function(e){var t;if(e)if(l)C.always(e[C.status]);else for(t in e)x[t]=[x[t],e[t]];return this},abort:function(e){var t=e||T;return o&&o.abort(t),r(0,t),this}};if(v.promise(C),d.url=((t||d.url||Ct.href)+"").replace(Rt,Ct.protocol+"//"),d.type=n.method||n.type||d.method||d.type,d.dataTypes=(d.dataType||"*").toLowerCase().match(qe)||[""],null==d.crossDomain){c=te.createElement("a");try{c.href=d.url,c.href=c.href,d.crossDomain=$t.protocol+"//"+$t.host!=c.protocol+"//"+c.host}catch(e){d.crossDomain=!0}}if(d.data&&d.processData&&"string"!=typeof d.data&&(d.data=de.param(d.data,d.traditional)),Y(It,d,n,C),l)return C;f=de.event&&d.global,f&&0===de.active++&&de.event.trigger("ajaxStart"),d.type=d.type.toUpperCase(),d.hasContent=!Ft.test(d.type),i=d.url.replace(Dt,""),d.hasContent?d.data&&d.processData&&0===(d.contentType||"").indexOf("application/x-www-form-urlencoded")&&(d.data=d.data.replace(qt,"+")):(h=d.url.slice(i.length),d.data&&(i+=(kt.test(i)?"&":"?")+d.data,delete d.data),d.cache===!1&&(i=i.replace(Ot,"$1"),h=(kt.test(i)?"&":"?")+"_="+jt++ +h),d.url=i+h),d.ifModified&&(de.lastModified[i]&&C.setRequestHeader("If-Modified-Since",de.lastModified[i]),de.etag[i]&&C.setRequestHeader("If-None-Match",de.etag[i])),(d.data&&d.hasContent&&d.contentType!==!1||n.contentType)&&C.setRequestHeader("Content-Type",d.contentType),C.setRequestHeader("Accept",d.dataTypes[0]&&d.accepts[d.dataTypes[0]]?d.accepts[d.dataTypes[0]]+("*"!==d.dataTypes[0]?", "+Mt+"; q=0.01":""):d.accepts["*"]);for(p in d.headers)C.setRequestHeader(p,d.headers[p]);if(d.beforeSend&&(d.beforeSend.call(g,C,d)===!1||l))return C.abort();if(T="abort",y.add(d.complete),C.done(d.success),C.fail(d.error),o=Y(Pt,d,n,C)){if(C.readyState=1,f&&m.trigger("ajaxSend",[C,d]),l)return C;d.async&&d.timeout>0&&(u=e.setTimeout(function(){C.abort("timeout")},d.timeout));try{l=!1,o.send(b,r)}catch(e){if(l)throw e;r(-1,e)}}else r(-1,"No Transport");return C},getJSON:function(e,t,n){return de.get(e,t,n,"json")},getScript:function(e,t){return de.get(e,void 0,t,"script")}}),de.each(["get","post"],function(e,t){de[t]=function(e,n,r,o){return de.isFunction(n)&&(o=o||r,r=n,n=void 0),de.ajax(de.extend({url:e,type:t,dataType:o,data:n,success:r},de.isPlainObject(e)&&e))}}),de._evalUrl=function(e){return de.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,throws:!0})},de.fn.extend({wrapAll:function(e){var t;return this[0]&&(de.isFunction(e)&&(e=e.call(this[0])),t=de(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){for(var e=this;e.firstElementChild;)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(e){return de.isFunction(e)?this.each(function(t){de(this).wrapInner(e.call(this,t))}):this.each(function(){var t=de(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)})},wrap:function(e){var t=de.isFunction(e);return this.each(function(n){de(this).wrapAll(t?e.call(this,n):e)})},unwrap:function(e){return this.parent(e).not("body").each(function(){de(this).replaceWith(this.childNodes)}),this}}),de.expr.pseudos.hidden=function(e){return!de.expr.pseudos.visible(e)},de.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},de.ajaxSettings.xhr=function(){try{return new e.XMLHttpRequest}catch(e){}};var Wt={0:200,1223:204},Bt=de.ajaxSettings.xhr();pe.cors=!!Bt&&"withCredentials"in Bt,pe.ajax=Bt=!!Bt,de.ajaxTransport(function(t){var n,r;if(pe.cors||Bt&&!t.crossDomain)return{send:function(o,i){var s,a=t.xhr();if(a.open(t.type,t.url,t.async,t.username,t.password),t.xhrFields)for(s in t.xhrFields)a[s]=t.xhrFields[s];t.mimeType&&a.overrideMimeType&&a.overrideMimeType(t.mimeType),t.crossDomain||o["X-Requested-With"]||(o["X-Requested-With"]="XMLHttpRequest");for(s in o)a.setRequestHeader(s,o[s]);n=function(e){return function(){n&&(n=r=a.onload=a.onerror=a.onabort=a.onreadystatechange=null,"abort"===e?a.abort():"error"===e?"number"!=typeof a.status?i(0,"error"):i(a.status,a.statusText):i(Wt[a.status]||a.status,a.statusText,"text"!==(a.responseType||"text")||"string"!=typeof a.responseText?{binary:a.response}:{text:a.responseText},a.getAllResponseHeaders()))}},a.onload=n(),r=a.onerror=n("error"),void 0!==a.onabort?a.onabort=r:a.onreadystatechange=function(){4===a.readyState&&e.setTimeout(function(){n&&r()})},n=n("abort");try{a.send(t.hasContent&&t.data||null)}catch(e){if(n)throw e}},abort:function(){n&&n()}}}),de.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),de.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return de.globalEval(e),e}}}),de.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),de.ajaxTransport("script",function(e){if(e.crossDomain){var t,n;return{send:function(r,o){t=de(" diff --git a/search_index.json b/search_index.json index cb4e04c55..9b2fc3bef 100644 --- a/search_index.json +++ b/search_index.json @@ -1 +1 @@ -{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["\"0.5.0\"","\"frameless","\"org.typelevel\"","%","%%","(e.g.","(e.g.,","(includ","(peopl","(thumb",")","++=","+1,","0.13.13:","0.4.0","0.4.1","0.5.0","1.0.0","1.0.1","2.0","2.0,","2.11.x.","2.2.0","2.2.1","2.3.2.","=",">=","access","add","adelbertc","aforement","against","allow","apach","api","api,","api.","appli","applic","are:","arithmet","associ","avail","base","benefit","bootstrap","break","bring","build.sbt","built","call","cast","cat","cats\"","cats,","cats.","chang","channel","choos","click","code","column","column,","columns)","compar","comparison","compat","compil","compile)","concept:","conduct","consist","consol","contribut","contributor","creat","current","custom","customizable,","dataset","dataset\"","dataset,","dataset/datafram","depend","detail","develop","document","easi","encod","encoder,","enhanc","environ","error","error)","essenti","exist","express","featur","feel","few","file","file.","follow","follows:","frameless","framelessvers","framelessversion,","free","friendli","function","g8","get","giter8","github,","gitter","gitter)","ground,","help?","here","http://opensource.org/licenses/apach","imario","imarios/frameless.g8","injection:","insid","instal","intention","introduc","introduct","issues/questions.","jar.","jeremyrsmith","job[a]","kanterov","learning.","librari","librarydepend","licens","list(","load","made","maintain","merg","messag","mf","minim","ml","ml\"","modul","modules:","more","need","needed:","new","next","non","note","numer","offici","olivierblanvillain","on","oper","overhead","overview","possibl","prefer","probabl","project","project:","projectio","proof","provid","pull","quick","rdd","rdds,","referenc","requests)","requests.","requir","runtim","safe","same","sbt","scala","shapeless","shell","sign","signatur","similar)","simpli","simply:","spark","spark'","spark).","spark.","standard","start","still","strongli","support","tabl","test","therefore,","type","typeddatafram","typeddataset","typeddataset.","typeddataset:","typelevel","types.","typesaf","under","up","up,","us","val","veri","version","versions.","want","way","well","well.","why?","with,","work"],"FeatureOverview.html":["\"abc\")","\"false\")","\"lyon\",","\"paris\")","\"paris\",","$\"*\".","'`citi`'","'city),","'name),","'population)","'price),","'project","(apttypedds)","(apttypedds2)","(column:","(enjoy","(frameless.typedcolumn[(string,","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(from","(if","(in","(lyon,166500.0))","(name:","(paris,333333.3333333333),","(string,","(such","(u:","(up","(which","(with",")",").as[apartmentdetails]",").as[aptpricecity].show().run",").as[stats].show().run()",").show().run()",").show(1).run()",").show(2).run()","*","+","...","...).",".ac",".dataset",".desc.",".select($\"*\",","/","//","0.0|","0.0|325000.0|","0.2,","1","1),","1.1|","10,","100,","10000.0,","102|","133000.0,","133000.0|","1|","1|250000.0|","2","2)","2),","2).as[updatedsurface]","2).show().run()","2.0","200000.0,","200000.0|","2229621),","2229621|","2409.6385542168673,","25,","250000.0,","250000.0|","250|","25|[paris,","27|","2955.5555555555557,","2|","2|300000.0|","2|[a,","3","3)","3),","300000.0,","300000.0|","325000.0,","325000.0|","343629)","343629|","3|","3|450000.0|","3|[a,","4","430","4391.891891891892)","4391.891891891892|","45,","4500.0,","450000.0,","450000.0|","450|","45|133000.0|","47|","50,","500715),","500715|","500|","52|","6833.333333333333|","74,","740|","76|","83,","830|","83|200000.0|","85|",":",":26:",":27:",":28:",":29:",":35:",":36:","=","==","===","=>","['citi]","[1...10]).","[_1:","[city#53,","[city,","[city:","[lyon,500715]|","[nice,343629]|","[out,","[ratio:","^","_1|","_2:","_2|","_3|","_4|","a)(implicit","ab","abov","access","accident","action","actual","ad","add","addit","adjustedpric","adjustedprice.show().run()","adjustedprice:","again","agg()","agg(avg(aptds('price))).","aggreg","aggregated,","agree.","align","align.","allcities:","allcities|","allow","allowed,","allowed:","alternatives:","and/or","anoth","anyth","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartment.","apartmentdetail","apartmentdetails(city:","apartmentdetails?","apartmentshortinfo","apartmentshortinfo(city:","apartmentshortinfo?","api","api,","api.","apis),","apis.","appear","appli","aptd","aptds('city),","aptds('price)","aptds('price)))","aptds('price),","aptds('surface),","aptds('surface).cast[double]","aptds('surface).cast[double])","aptds.","aptds.agg(","aptds.select(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)","apttypedds('city)).as[updatedsurface]","apttypedds('city).asc,","apttypedds('city).cast[double]","apttypedds('price).desc","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.joininner(citiinfotypedds)","apttypedds.makeudf(pricemodifier)","apttypedds.orderby(","apttypedds.orderby(apttypedds('city).asc).show(2).run()","apttypedds.project[apartmentshortinfo]","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds.union(apttypedds2).show().run","apttypedds2","apttypedds2('price)","apttypedds2('price)).","apttypedds2.drop[citybeds]","apttypedds2.droptupled('price):","apttypedds2.union(apttypedds).show().run","apttypedds2.withcolumnreplaced('price,","apttypedds2.withcolumntupled(","apttypedds2.withcolumntupled(lit(array(\"a\",\"b\",\"c\"))).show(2).run()","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","argument","arguments)","around","array]","arraycontains(t('_1),","arraycontains(t('_2),","arraycontains:","as:","as[bedroomstats]","as[t]","ascol()","ascol(),","avail","available.","averag","avg","avg(aptds('price))","avg(aptds('price)),","avg(aptds('surface))","avg(aptds('surface)),","avgprice:","avgpricebeds1:","avgpricebeds2:","avgpricebeds3:","avgpricebeds4:","avgprice|","avgsurface:","avgsurface|minsurface|","avoid","b,","base","bedroom","bedrooms#56]","bedrooms.","bedrooms:","bedrooms];;","bedroomstat","bedroomstats(","bedroomstats('avgpricebeds2).getorelse(0.0),","bedroomstats('avgpricebeds3).getorelse(0.0))","bedroomstats(lyon,some(133000.0),some(200000.0),none,none)","bedroomstats(nice,none,none,some(325000.0),none)","bedroomstats(paris,some(250000.0),some(300000.0),some(450000.0),none)","bedroomstats.collect().run().foreach(println)","bedroomstats.select(","bedroomstats.show().run()","bedroomstats:","better","between","boolean","boolean)].","c","c('_2)).show(2).run()","c,","c.","c.select(c.colmany('_1,","c.show(1).run()","c:","c]|","calcul","call","caller","can't","care","case","case.","cast","cast,","catalystcast.","catalystcast[string,","chang","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name)","city:","cityb","citybeds(city:","citybeds(lyon,2))","citybeds(paris,1))","citybeds(paris,1),","citybeds(paris,3))","citybeds(paris,3),","citybeds.","citybeds.head(3).run()","citybeds.headoption.run()","citybeds.limit(4).collect().run()","citybeds.select(citybeds.ascol,","citybeds.take(2).run()","citybeds:","citybedsoth","citybedsother(city:","cityinfo","cityinfo(city:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.select(cityratio('city),","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|avgpricebeds1|avgpricebeds2|avgpricebeds3|avgpricebeds4|","city|bedrooms|","city|surface|","class","class:","clause.","code","collect","collect())","collection,","collectset(aptds('city))","colmany()","column","column.","column:","columns,","columns:","combin","compar","compat","compil","compile,","compile.","compile:","compiles:","complet","comput","computations.","concat,","condition","conf","context","continu","convert","correspond","count,","creat","d]|true|","data","datafram","dataframes,","dataset","dataset.","dataset:","defin","detail","direct","directli","divid","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","drop","drop().","drop/replace/add","droptupled()","e.g.,","e:","each","easili","element","elements.","elid","empti","encod","entir","equival","error","error.","error:","evid","evidence$1:","exampl","example,","example.","exist","expect","explan","explicitli","expos","express","expression'","extra","featur","few","field","field]","fields.","fields]","finally,","find","first","five","follow","form","formal","found","frameless","frameless'","frameless,","frameless.abstracttypedcolumn[?t,?c[?a]]","frameless.abstracttypedcolumn[t,c[a]]","frameless.abstracttypedcolumn[t,c[a]],","frameless.catalystcast[string,double]","frameless.catalystcollection[c])column.thistype[t,boolean]","frameless.catalystdivisible[double,out],","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.functions._","frameless.functions.aggregate._","frameless.functions.lit","frameless.functions.nonaggregate._","frameless.functions.nonaggregate.when","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[(string,","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[tt,double])(implicit","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(citybeds,","frameless.typeddataset[(double,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[apartmentshortinfo]","frameless.typeddataset[bedroomstats]","frameless.typeddataset[citybeds]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","frameless.typedencoder[out],","frameless.with[apartment,tt]{typ","function","functions.","further","gener","get","getorelse().","give","given","group","groupbi","groupby()","groupby(aptds('city)).","here","here.","however,","id","if(nam","implicit","import","includ","inflat","inflation.show(2).run()","inflation:","inform","initi","input","instanc","instances:","instanti","instead.","int","int)","int).","int)]","int,","int.","int]","interest","introduc","job","join","lazi","lazy.","let","let'","lift","list[string])","list[string]),string]","list[string]),string],","list[string])]","lit(0.001))","lit(1.1)).","lit(list(\"a\",\"b\",\"c\")))","lit(list(\"abc\",\"c\",\"d\")))","litaggr(\"hello","liter","localrel","long","look","loos","lyon]|","lyon|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","macro","main","make","mani","match","materialize.","math","matter","member","method","method,","method.","min(aptds('surface)),","min(aptds('surface)).cast[double],","minimum","minsurface:","mismatch;","miss","missing,","misspel","mistak","more","n","n:","name","name:","names/typ","names/types,","need","nest","new","next","next,","nice,","nice|","nice|325000.0|","non","none).","not,","note","now","null|","number","often,","on","on(1,2,3,4).","oper","operation.","operations:","option","option.","option[citybeds]","option[double])","option[double],","order","order.","org.apache.spark.sql,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:88)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$6.apply(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1$1.apply(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$transformexpressionsup$1.apply(queryplan.scala:268)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:289)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:268)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:70)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:289)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:127)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:187)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:288)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:67)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2884)","org.apache.spark.sql.dataset.select(dataset.scala:1150)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:52)","org.apache.spark.sql.sparksess","org.apache.spark.{sparkconf,","origin","other:","otherwise(lit(0.0))).show(8).run()","other|","out","overload","overview","paramet","particular","per","perform","perhap","pivot","pivot(aptds('bedrooms)).","pivot,","popul","population:","potenti","prefer","preserv","price","price#55,","price,","price/surfac","price:","price:double)","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","price|bedrooms|","project","project,","prove","rais","ratio","ratio:","ratio|","readi","referenc","repl\").set(\"spark.ui.enabled\",","replac","requir","required:","res17:","res19:","res27:","res28:","res29:","res30:","res35:","res6:","resolv","result","result.","retriev","return","right?","row","run()","runtim","safe","safe,","safe.","safety,","safety.","same","samplestat","samplestats.show().run()","samplestats:","scala","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","schema","schema.","secondari","see","seem","select","select()","selectmany()","selectmany,","seq(","seq[(string,","seq[citybeds]","seq[double]","set","shapeless.tag.tagged[string(\"citi\")]","shorter","show","show()","show(1).run()","similarly,","simpl","singl","skip","some(citybeds(paris,2))","sort","sorting.","sourc","spark","spark'","spark.createdataset(apartments)","spark.implicits._","spark.sparkcontext.setloglevel(\"warn\")","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","stack","standard","start","stat","stats(","string","string(\"abc\")","string)","string),updatedsurface]","string,","string.","string]","struct,","struct]","subset","suggests,","sum,","support","suppos","surfac","surface#54,","surface,","surface:","symbol","syntax:","t","t.withcolumntupled(","t:","take","tell","ten","those","three","time","time,","top","trace):","transform","transformations.","tri","tt,","tupl","tutori","type","type:","type;","typedaggreg","typedcolumn","typeddataset","typeddataset.","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[(string,int)]","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[apartmentshortinfo]","typeddataset[citybeds]","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","types,","typesaf","typesafeti","typo","u","udf","udf(aptds('city),","udf:","underli","union","unit:","unlik","unsaf","up","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","val","valid","valu","value.","value:","vector[string])","w:","w](other:","want","way","way,","well.","when(apttypedds2('city)","when/otherwis","whenev","wherea","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withcolumn()","withcolumn(),","withcolumn[citybedsother](lit(list(\"a\",\"b\",\"c\"))).","withcolumntupled()","without","work","worked,","world\")","world|","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","wrappedarray(citybeds(paris,2),","w})frameless.typedcolumn[w,out]","{","|","|1000|102|","|200000.0|","|276333.3333333333|62.833333333333336|","|300000.0|450000.0|","|4500.0|450000.0|","|6000.0|300000.0|","|6908333.333333333|12.566666666666668|hello","|[lyon,45,133000.0,1]|","|[lyon,83,200000.0,2]|","|[nice,74,325000.0,3]|","|[paris,100,450000...|[paris,2229621]|","|[paris,25,250000....|[paris,2229621]|","|[paris,2]|[a,","|[paris,50,300000....|[paris,2229621]|","|city|surface|","|lyon|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|paris|[a,","|paris|[abc,","}"],"TypedDatasetVsSparkDataset.html":["\"e\")","\"java.util.date\",","\"jday\")","\"mydate\"","\"q\")","\"w\")","$\"i\"*2)","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","&&","'(sum(`i`)","'`i`'","'`x`'","'project","(case","(class:","(i","(i#1771l","(int,","(isnotnull(i#1771l)","(look","(or","(see","(the",")","*","*deserializetoobject","*filescan","*filter","*mapel","*project","*serializefromobject","+",",","...",".appli","//","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10).select(fds('i)).explain()","10).select(fds('i)).show().run()","10).select(fds('x))","10|","1|","2)#1890l]","454","770","854",":",":20:",":24:",":25:",":26:","::","=","==","===","=>","['x]","[],","[a]frameless.typedcolumn[foo,a]","[i#1771l","[i#1771l,j#1772]","[i#1771l]","[i,","[i:","[input[0,","[isnotnull(i),","[out]frameless.typedaggregate[foo,out]","[sum(i#1771l)","^","_1#1876l]","_1|","`sum(i)`)'","above.","access","achiev","act","ad","aggreg","allow","api","appli","applications.","area","argument","as[long]","assum","averaging,","avoid","bar","bar(1)))","bar(i:","batched:","before.","between","bigint","bigint))","bigint,","bigint]","bind","both","bug","bulletproof:","captur","care","case","cast","cast(10","cast(2","catalyst","class","class:","classes)","clearli","closur","closures.","code","code.","column","columnar","columns,","columns:","compar","comparison,","compil","compromis","confus","content","context","correct.","correctli","creat","current","dataset","dataset.","dataset[long].","datasets,","defin","detail.","detect","differ","discuss","discussion.","disk","distinguish","don't","ds","ds.filter($\"i\"","ds.filter(_.i","ds.select(sum($\"i\"),","ds.show()","ds:","each","elid","empty,","encod","encoder:","entir","equalto(i,10)],","error","error.","error:","etc)","exampl","example,","exist","expect","explain","explicitli","express","extrem","e|","fail","failure:","false]","familiar","fd","fds('i)).show().run()","fds.agg(fsum(fds('i))+22).show().run()","fds.agg(fsum(fds('i)),","fds.filter(fds('i)","fds.select(fsum(fds('i)))","fds:","few","field","fields.","file","file.","filter","filteredd","filteredds.explain()","filteredds.show()","filteredds:","find","first","first()","first,","first_value)","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo,","foo.","format","format:","found","frameless","frameless'","frameless,","frameless.functions.aggregate.{sum","frameless.functions.aggregate.{sum=>fsum}","frameless.syntax._","frameless.typedaggregate[foo,?]","frameless.typedcolumn[foo,?]","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[mydate]","frameless:","friend.","fsum}","fulli","function","function(s)","function.","futur","generated.","get.;;","give","given","goal:","great!","group","guard","handhold","help","here","here.","hold","however,","implement","implicit","import","improv","incompat","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inmemoryfileindex[file:/tmp/foo],","input","insid","instanti","instead.","int)","introduc","intuitively,","it'","i|","j.","j:","j];;","java.lang.unsupportedoperationexception:","java.util.d","java.util.date(system.currenttimemillis))))","java.util.date)","j|","know","last","lead","let'","limit","line","linux","load","location:","long","long,","look","mac","make","map","member","members.","mention","method","mistak","mix","more","mydat","mydate(jday:","name","name:","need","newinstance(class","next","nil","non","note","notifi","now,","obj#1803:","obj#1804:","ok","on","oper","operations,","optim","optimizer)","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.analyzer.failanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:88)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$9.apply(checkanalysis.scala:280)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$checkanalysis$class$$anonfun$$checkvalidaggregateexpression$1$5.apply(checkanalysis.scala:253)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:280)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.org$apache$spark$sql$catalyst$analysis$checkanalysis$class$$anonfun$$checkvalidaggregateexpression$1(checkanalysis.scala:239)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.org$apache$spark$sql$catalyst$analysis$checkanalysis$class$$anonfun$$checkvalidaggregateexpression$1(checkanalysis.scala:253)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.failanalysis(checkanalysis.scala:39)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:71)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$6.apply(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1$1.apply(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$transformexpressionsup$1.apply(queryplan.scala:268)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:289)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:268)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1$$anonfun$10.apply(scalareflection.scala:614)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1$$anonfun$10.apply(scalareflection.scala:626)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1.apply(scalareflection.scala:455)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1.apply(scalareflection.scala:614)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1.apply(scalareflection.scala:632)","org.apache.spark.sql.catalyst.scalareflection$.cleanupreflectionobjects(scalareflection.scala:39)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:455)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:444)","org.apache.spark.sql.catalyst.scalareflection$class.cleanupreflectionobjects(scalareflection.scala:809)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:70)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:289)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:127)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:187)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:288)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:67)","org.apache.spark.sql.dataset.(dataset.scala:165)","org.apache.spark.sql.dataset.(dataset.scala:171)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2884)","org.apache.spark.sql.dataset.select(dataset.scala:1150)","org.apache.spark.sql.dataset.select(dataset.scala:1210)","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:275)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:52)","org.apache.spark.sql.functions.sum","org.apache.spark.sql.lowprioritysqlimplicits$class.newproductencoder(sqlimplicits.scala:233)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:33)","os","paramet","parquet","parquet,","partial","partitionfilters:","pass","performance.","physic","plan","plan,","plan.","plan:","polymorph","popular","practic","primit","problem","problem.","problemat","product","product,","project","projections/selections.","provid","pushedfilters:","queri","quick","q|","read","readschema).","readschema:","refer","relation[i#1771l,j#1772]","releases.","remind","requir","required:","resolv","result","return","root","run","runtim","safe","safe.","safety!","safety.","save","scala","scala.","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala.reflect.internal.tpe.typeconstraints$undolog.undo(typeconstraints.scala:56)","scala>","schema","second,","see","select","select()","sense,","separately,","sequenc","serial","serv","set","shapeless.tag.tagged[string(\"x\")]","show","similarly,","simpl","simplist","slow","small","solut","solv","spark","spark'","spark.","spark.createdataset(","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark:","sparksess","standard","start","statement","statement).","store","string)","string,","string]","struct","subset","such","suffici","suggests,","sum","sum(i)#1889l,","support","symbol","syntax","syntax.","take","thing","this.","time","time.","time:","togeth","tri","true,","tutori","two","two.","type","type.","type;","typedaggreg","typedcolumn","typeddataset","typeddataset.","typeddataset.create(ds)","typeddataset.create(seq(mydate(new","unabl","unfortunately,","us","val","valu","value#1805l]","veri","view","vs","want","way","well","window","without","work","wrap","w|","x","x:","|","|100|","|133|","|value|"],"TypedEncoder.html":["\"s\"))))","\"s\",","(a","(and","//","2.0)",":24:",":28:",":30:","=","[i:","^","annoy","approach","around","b:","bar","bar(1.1,","bar(d:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","behav","besid","call","care","case","class","classes.","code","compil","construct","coupl","current","custom","data","data.","dataset","dataset?.","dataset[daterange]","daterange(s:","decod","defin","deriv","derived,","detect","different,","double,","ds.collect()","ds:","e:","encod","encoder.","encoder:","encoders,","ensur","error","error:","exampl","example,","exist","expected:","extend","fail","find","follow","foo","foo(i:","foodate(i:","found:","frameless","frameless.job$$anon$4@558c6c17","frameless.job[seq[foo]]","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless:","gener","goe","hierarchi","ident","implicit","implicitli","import","inabl","int,","intern","introduc","issues.","java.util.d","java.util.date)","java.util.date)))","java.util.date))))","java.util.date,","jvm","lead","limit","manipul","mechan","method","more","new","non","note","object","of)","onc","org.apache.spark.sql.dataset","overflow","paramet","pass","performance.","prove","question","recurs","reflect","represent","res2:","resolut","run","runtim","runtime.","s:","same","scala>","scalareflect","schema.","see","shapeless'","shown","situat","solv","spark","spark'","spark.implicits._","spark:","sqlcontext","sqlcontext.createdataset(seq(daterange(new","stack","standard","store","string)","string,","struct]","summari","support","t:","take","through","time,","time.","time:","trace,","tri","type","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeencod","types.","us","val","valu","vanilla","won't","work"],"Injection.html":["$anon$1@37f23430","//","1","15:18:58","18","2","2018))","3",":23:",":31:","=","=>","[age:","^","a):","again","anoth","apply(a:","apply(d:","available,","b","b):","b.","b]","bigint]","birthday:","can't,","case","class","class:","compil","creat","custom","d.gettime()","datetolonginject","datetolonginjection:","def","defin","definit","encod","encoder:","error.","error:","exampl","extend","family:","feb","femal","find","frameless._","frameless.injection$$anon$1@4d1cf7ad","frameless.injection$$anon$1@6cd20faa","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.typeddataset[person]","frameless.typedencoder[person]","function:","gender","gender)","gender:","gendertoint:","implicit","import","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","instanc","int,","int]","invert(b:","invert(l:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date)","java.util.date))","java.util.date).gettime(),","java.util.date):","java.util.date.","less","let","let'","list(person(42,male))","list(person(42,sun","long","long)))","long):","long:","long]","look","male","male))","more","new","now","object","on","paramet","peopl","people:","person","person(age:","persond","personds:","precis","pst","seal","seq(person(42,","seq[person]","serializ","simpl","trait","tri","type","type,","typeclass:","typeddataset,","typeddataset.create(people)","typeddataset:","typedencod","us","val","valu","verbos","{","}","})","},"],"Job.html":["(a","(sample:","//","1","20%","20)","=","=>","[_1:","abil","above)","above,","allow","along","annotate/nam","applic","be","block","calcul","call","captur","cat","cats.effect.sync","collect","compar","complex","compos","composit","comprehens","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","constructor","count","countandtakejob","data","def","default","description.","differ","driver","ds","ds:","easier","effect","effects.","element","elements:","exactli","exampl","example,","execut","expens","explicit","explicitli","f[_]","f[a]","f[a],","few","finaljob","finaljob.","finaljob:","first","frameless.","frameless.job","frameless.job$$anon$2@30c69a34","frameless.job[int]","frameless.job[seq[int]])frameless.job[int]","frameless.syntax._","frameless.typeddataset[int]","functions:","further","group","have","help","id","implement","implicitli","import","inform","instanc","instance.","int","int]","issues.","job","job[a]","job[int]","job[seq[int]]):","jobs.","lazi","lazili","lazy,","lazy.","make","mention","min\").","module,","monad","more","new","non","now","obviou","open","oper","order","part","pass","perform","place","predict","program","programm","provid","repres","requir","res2:","result","return","run","run()","sample.map(_.min)","say,","see","sequenc","serv","sever","show","showcas","size","spark","spark.","sparkdelay","sparkdelay[f[_]]","sparksession.","specifi","strict","such","support","suspend","suspens","thunk","toy","track","track,","transform","type","typeclass","typeclass,","typeddataset","typeddataset.create(1","ui","us","user","val","value,","via","withdescription(\"sampl","withgroupid(\"samplingjob\").","{"],"Cats.html":["\"another\")))","\"string\"),","\"task2\"","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(0,0,0)","(1,","(1,2,3)","(10,9,9)","(2,","(8,","(8,2,3)","(and","(chris,map(0","(john,map(0","(sam,map(0","(semigroup)","(seq[(int,","(wrappedarray((1,string)),2)",")","//","1","1)","1))","1)),","1),","1,","10))","10,","100)","11))","12)","12,","15)))","2","2)","2))","2)),","2,","20)","20,","3)","3))","3,","32,","4))","4)),","4,","5,","6,",":44",":46",":47",":50","::","=",">","[_1:","_2:","abil","above.","abstract","action","action[(seq[(int,","action[t]","aggreg","algebra","alia","alias","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","anna","api","arbitrari","arity.","array((joe,map(0","array[(username,","assum","avg,","be","below","block","capabl","captur","case","cat","cats.data.readert","cats.effect.implicits._","cats.effect.io","cats.effect.sync[f].","cats.implicit","cats.implicits._","cats.mtl.implicits._","cats:","class","cmax","cmin","collect","column","combin","common","complex","comput","constructor","conveni","counterpart","csum,","data","data.","data:","dataset","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","deal","default","defin","delay","descript","description:","differ","effect","effect:","effects.","element","empti","empty,","emptyrdd","emptyrdd[15]","enhanc","enrich","etc.","exampl","example,","example:","execut","exist","f[_]","f[_],","fanci","first","follow","frameless","frameless.cats.implicits.","frameless.cats.implicits._","frameless.cats.implicits._.","frameless.cats.outer._","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[(int,","frameless:","full","general).","given","group","implicit","implicits.scala:42","implicits.scala:67","import","insid","instanc","int","int)]","int,","integr","io","job,","joe","join","kernel","key","key.","keys.","larg","layer","lazy.","leverag","library:","local","long)","long)]","machineri","main","makerdd","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[25]","mapvalu","max,","meaning","method","min,","modifi","module,","monad","more","mtl","namely,","need","nil","nil)","none","normal","note","noth","now,","offer","on","oper","option","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","outer","over","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","pair","parallelcollectionrdd[14]","parallelcollectionrdd[16]","parallelcollectionrdd[18]","parallelcollectionrdd[20]","parallelcollectionrdd[21]","part","plain","pre","predicates.","previous","println(data.cmax)","println(data.cmaxoption)","println(data.cmin)","println(data.cminoption)","println(data.csum)","println(data.csumoption)","program,","properli","provid","r","rdd","rdd.","rdd:","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","readert","readert[io,","reducebykey","repres","request","res16:","res17:","res19:","res20:","res5:","res6:","result","result.run(spark).unsaferunsync()","result:","resultwithdescription.run(spark).unsaferunsync()","resultwithdescription:","return","run","run:","same","sampl","sc.emptyrdd","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala.collection.immutable.sortedmap","scala.collection.immutable.sortedmap[string,int])]","scala.collection.map[string,scala.collection.immutable.sortedmap[string,int]]","scala.collection.map[user,transactioncount]","section","semigroup","set","show","shuffledrdd[17]","shuffledrdd[19]","simplifi","sort","sortedmap(\"task1\"","sortedmap(\"task3\"","spark","sparkdelay","sparkdelay[f].","sparksess","sparksession,","sparksession.","stack","stack.","stack:","string","string)]","string)],","string]","suppli","suspend","suspended.","suspens","syntax","t]","task","task2","task3","those","thread","timeseri","timeseries)]","togeth","together.","totalperus","totalperuser.collectasmap","totalperuser:","transactioncount","transactioncount)]","tupl","two","type","type.","typeclass","typedd","typeddataset","typeddataset.create(seq((1,","typedds:","us","user","user'","usernam","util","val","valu","variabl","way","work","work,","wrap","yet.","{","|+|"],"TypedML.html":["\"\",","\"lyon\",","\"san","(0","(empti","(name","(repres","(see","(the","(what","(which",")","))","...",".as[housedatawithfeatures]","//","0)))","1","1,","1.0","100000)))","100000),","1:","2","2))","2,","2.0","200000),","250000),","2:","3","3)","4","500000)","500000),","800000)))","900000)",":)",":37:",":39:","=",">","[1.0,2.0,3.0]","[_1:","[features:","[squarefeet:","^","_2:","abov","abstract","accept","add","another,","api","api,","append","array","array(1,","as:","assembl","assembler.transform(testdata).as[housedatawithfeatures]","assembler.transform(trainingdata)","assembler.transform(trainingdata).as[housedatawithfeatures]","assembler.transform(trainingdata).as[wronghousefeatures]","assembler.transform(wrongtrainingdata)","assembler:","back","base","boolean","boolean)","boolean,","boolean:","both","call","calls,","case","case)","cast","categor","check","citi","city.","city:","cityindexed:","class","close","code","column(s)","column(s).","companion","compil","comput","contain","continu","contrari","contribut","correct","current","data","data)","data,","datafram","datawithfeatur","datawithfeatures:","deal","default","defin","depend","deriv","detail","document","doubl","double)","double,","double]","encod","equival","error:","estimator.","estimators.","exampl","example,","exclus","fact","false,","featur","features(price:","features(squarefeet:","features).","features):","features.","features:","feed","field","field]","fields]","find","fit","footag","footage.","forest,","frameless","frameless._","frameless.ml._","frameless.ml.appendtransformer[rfinputs,frameless.ml.classification.typedrandomforestclassifier.outputs,org.apache.spark.ml.classification.randomforestclassificationmodel]","frameless.ml.appendtransformer[rfinputs,frameless.ml.regression.typedrandomforestregressor.outputs,org.apache.spark.ml.regression.randomforestregressionmodel]","frameless.ml.appendtransformer[stringindexerinput,frameless.ml.feature.typedstringindexer.outputs,org.apache.spark.ml.feature.stringindexermodel]","frameless.ml.classification._","frameless.ml.classification.typedrandomforestclassifier@be7ee","frameless.ml.classification.typedrandomforestclassifier[rfinputs]","frameless.ml.feature._","frameless.ml.feature.typedindextostring@c97d749","frameless.ml.feature.typedindextostring[indextostringinput]","frameless.ml.feature.typedstringindexer@666bcbec","frameless.ml.feature.typedstringindexer[stringindexerinput]","frameless.ml.feature.typedvectorassembler@159b3f1","frameless.ml.feature.typedvectorassembler@66b12f1","frameless.ml.feature.typedvectorassembler[features]","frameless.ml.regression._","frameless.ml.regression.typedrandomforestregressor@4c620c93","frameless.ml.regression.typedrandomforestregressor[rfinputs]","frameless.ml.typedestimator$$anonfun$fit$1$$anon$1@20355c2f","frameless.ml.typedestimator$$anonfun$fit$1$$anon$1@36ed2d44","frameless.ml.typedestimator$$anonfun$fit$1$$anon$1@5a0797","frameless.ops.as[(double,","frameless.syntax._","frameless.typeddataset[(string,","frameless.typeddataset[housecityprediction]","frameless.typeddataset[housecitypredictionindexed]","frameless.typeddataset[housecitypredictioninputs]","frameless.typeddataset[housedata]","frameless.typeddataset[housedatawithfeatures]","frameless.typeddataset[housedatawithfeaturesandindex]","frameless.typeddataset[housepriceprediction]","frameless.typeddataset[wronghousedata]","francisco\",","francisco)","from)","garden","hasgarden","hasgarden:","here","hood,","hous","housecitypredict","housecityprediction(","housecitypredictionindex","housecitypredictionindexed(","housecitypredictioninput","housecitypredictioninputs(features:","housedata","housedata(100,","housedata(150,","housedata(20,","housedata(200,","housedata(50,","housedata(squarefeet:","housedata?","housedatawithfeatur","housedatawithfeatures(squarefeet:","housedatawithfeaturesandindex","housedatawithfeaturesandindex(","housepricepredict","housepriceprediction(","i.","ignor","implement","implicit","import","index","indexeddata","indexeddata:","indexedpredict","indexedpredictions:","indexedtestdata","indexedtestdata.project[housecitypredictioninputs]","indexedtestdata:","indexer.fit(datawithfeatures).run()","indexer:","indexermodel","indexermodel.transform(datawithfeatures).as[housedatawithfeaturesandindex]","indexermodel.transform(testdatawithfeatures).as[housedatawithfeaturesandindex]","indexermodel:","indextostr","indextostring.transform(indexedpredictions).as[housecityprediction]","indextostring:","indextostringinput","indextostringinput(predictedcityindexed:","input","instanc","int,","introduc","it.","label","label)","label):","label,","level","leverag","list","locat","lowest","make","matrices.dense(2,","matrix","matrix))","matrix:","matrix]","matrixd","matrixds:","member","method","miss","ml","ml'","model","model.","model.transform(testdata)","model.transform(testdatawithfeatures)","model.transform(testdatawithfeatures).as[housepriceprediction]","model.transform(testinput).as[housecitypredictionindexed]","model:","modul","more","moreover,","name","need","new","not.","now","numer","object.","on","order","org.apache.spark.ml.linalg._","org.apache.spark.ml.linalg.matrix","org.apache.spark.ml.linalg.matrix)]","org.apache.spark.ml.linalg.matrix:","org.apache.spark.ml.linalg.matrixudt.","org.apache.spark.ml.linalg.vector","org.apache.spark.ml.linalg.vector),wronghousefeatures]","org.apache.spark.ml.linalg.vector)]","org.apache.spark.ml.linalg.vectorudt","org.apache.spark.sql.types.userdefinedtype[a]","overview):","paramet","pass","perhap","pleas","possibl","predict","predict).","predictedcity:","predictedcityindexed.","predictedcityindexed:","predictedprice:","predictions.select(predictions.col('predictedcity)).collect.run()","predictions.select(predictions.col('predictedprice)).collect.run()","predictions:","previou","previous","price","price:","probability:","project","prove","provid","random","rawprediction:","repres","res6:","res8:","return","reus","rf","rf.fit(indexeddata).run()","rf.fit(trainingdatawithfeatures)","rf.fit(trainingdatawithfeatures).run()","rf.fit(wrongtrainingdatawithfeatures)","rf:","rfinput","rfinputs(cityindexed:","rfinputs(price:","rfinputs.","safe","safeti","sale","same","seq[double]","seq[string]","snippet,","spark","spark).","squar","squarefeet:","stay","string","string)","string,","stringindexerinput","stringindexerinput(city:","strongli","structur","subsequ","take","term","test","testdata","testdata.","testdata:","testdatawithfeatur","testdatawithfeatures:","testinput","testinput:","thank","then,","time","time.","train","trainingdata","trainingdata:","trainingdatawithfeatur","trainingdatawithfeatures:","transform","true,","type","type.","typeddataset","typeddataset'","typeddataset.","typeddataset.create(seq(","typeddataset.create(seq(\"label\"","typeddataset.create(seq(housedata(120,","typeddataset.create(seq(housedata(20,","typeddataset.create(seq(housedata(70,","typeddataset.create(seq(wronghousedata(20,","typeddataset:","typeddatasets.","typedencod","typedencoder[a]","typedestim","typedestimator,","typedestimators,","typedindextostr","typedindextostring[indextostringinput](indexermodel.transformer.labels)","typedrandomforestclassifi","typedrandomforestclassifier.","typedrandomforestclassifier[rfinputs]","typedrandomforestregressor","typedrandomforestregressor.","typedrandomforestregressor[rfinputs]","typedrandomforestregressor[wrongrfinputs]","typedstringindex","typedstringindexer[stringindexerinput]","typedtransform","typedtransformercan","typedvectorassembl","typedvectorassembler[features]","typedvectorassembler[wrongfeatures]","types)","types,","types.","under","us","usual","val","valid","valu","vector","vector)","vector))","vector,","vector:","vector]","vectorassembl","vectorassembler)","vectorassembler.transform(testdata).as[housedatawithfeatures]","vectorassembler.transform(trainingdata).as[housedatawithfeatures]","vectorassembler:","vectord","vectords:","vectors.dense(1,","vectors:","veri","want","wrappedarray(420000.0)","wrappedarray(san","wrong","wrongfeatur","wrongfeatures(squarefeet:","wronghousedata","wronghousedata(squarefeet:","wronghousedata?","wronghousefeatures(","wrongrfinput","wrongrfinputs(labelofwrongtype:","wrongtrainingdata","wrongtrainingdata:","wrongtrainingdatawithfeatur","wrongtrainingdatawithfeatures:"],"TypedDataFrame.html":["\"dummy\"","\"unique\"","').map(r","'_4)","'q',","'s)","'x',","'z'))","'z'.","(((((((((","(implicit","(phonebooktf:",")",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","//","1.6","1.6+,","1.6,","11","2.10,","2.11","2.11,","22.",":",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","=>","???","addit","address","address,","address:","alphabet:","alternatively,","amount","api","approach","approxim","ariti","avail","away:","b:","bar(i:","bestneighborhood","boolean","boolean)","boolean):","boolean)]","boolean,","both","bring","c:","call","case","catch","caught","caus","citi","citymapentry(","citymaptf:","class","column","columns.","come","common","commonli","compar","compat","compil","complet","comput","concept:","consid","consist","contain","conveni","correct","count:","d:","data","datafram","dataframe,","dataframes,","dataset","def","defin","definit","deprec","design","develop","differ","directli","dive","document.","domain","done","doubl","double,","due","each","earli","element","enough","ensur","essenti","everyth","exampl","example:","except","execut","exist","expect","f","f.neighborhood))","f.residents.split('","fact","family(residents:","field","filter(conditionexpr:","first","flat","focu","follow","foo(s:","frameless","frameless.","frameless.typeddatafram","frameless:","function","further","futur","get","go","goal","goe","handl","have","here","hold","however,","i:","ident","import","improv","inform","instead","int)","int,","interest","intermedi","introduc","introduct","invalid","j:","job","jobs.","join","join1(tf1:","join2(tf1:","joins,","keep","languag","less","let","let'","letter","level","leverag","librari","like,","limit","limitations.","line","long)","long)])","look","main","manag","manipul","manner.","map","mirror","mistak","model","moder","more","much","name","name.exists(set('x',","names,","natur","need","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","neighborhoods:","nlplib","nlplib.uniquename(p.name)","now","number,","object","obtain","ontypeddataframe.","onward.","org.apache.spark.sql.datafram","org.apache.spark.sql.sqlcontext","p","packag","pair","person(name:","person(r,","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","point,","possibl","process","product.","proof","provid","public","readability.","readabl","reasons,","refer","referenc","represent","residents:","result","rethought","return","right","sadly,","safe","safety.","scala","schema","schema.","second","see","see,","seem","select","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","shadow","shapeless.hlist","signatures:","similar","simplifi","singl","spark","spark'","spark,","sqlcontext):","stage","still","store","string","string):","string)]","string)])","string,","suppos","syntax","syntaxes.","system","systems,","tabl","table,","tables:","target","tdataframe[schema","tdataframe[schema]","techniqu","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","time.","track","troubl","tuple23","two","type","type,","type.","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry])","typeddataframe[citymapentry].","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","types:","typo,","uniqu","uniquename(name:","us","user","valu","vanilla","variou","veri","version","way","well,","won't","work","zero.","{","}"]},"length":9},"tokenStore":{"root":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"1":{"3":{"docs":{},".":{"1":{"3":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"docs":{}},"docs":{}}},"docs":{}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"4":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"1":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"docs":{}}},"5":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"docs":{}}},"docs":{}},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"1":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"i":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"docs":{},":":{"1":{"8":{"docs":{},":":{"5":{"8":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"8":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.010282776349614395},"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}},".":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"1":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}},"docs":{}}},"1":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"6":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"+":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"docs":{}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.007712082262210797},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},")":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"docs":{}},"docs":{}},"docs":{}},"1":{"8":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"docs":{}},"docs":{},"%":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"4":{"0":{"9":{"docs":{},".":{"6":{"3":{"8":{"5":{"5":{"4":{"2":{"1":{"6":{"8":{"6":{"7":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},")":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"9":{"5":{"5":{"docs":{},".":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006201550387596899},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"1":{"0":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{},"x":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}},"2":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}},"1":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"docs":{}}},"3":{"docs":{},".":{"2":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"docs":{}}},"docs":{}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},"#":{"1":{"8":{"9":{"0":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0031007751937984496}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"4":{"3":{"6":{"2":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"4":{"3":{"0":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"9":{"1":{"docs":{},".":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"4":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"docs":{}},"docs":{}},"7":{"1":{"5":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"6":{"8":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"7":{"4":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"7":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"docs":{}},"docs":{}},"8":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"5":{"4":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"\"":{"0":{"docs":{},".":{"5":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"docs":{}}},"docs":{}}},"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.008595988538681949}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.008595988538681949}}}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"q":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"w":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"a":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"2":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"docs":{}}}}},"\"":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"d":{"docs":{},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"y":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"%":{"docs":{"./":{"ref":"./","tf":0.008595988538681949}},"%":{"docs":{"./":{"ref":"./","tf":0.008595988538681949}}}},"(":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"0":{"docs":{},",":{"0":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}}},"docs":{}}},"docs":{}}},"1":{"0":{"docs":{},",":{"9":{"docs":{},",":{"9":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}}},"docs":{}}},"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"2":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"8":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},",":{"docs":{"./":{"ref":"./","tf":0.008595988538681949}}}}}},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"y":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}},"t":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"#":{"1":{"7":{"7":{"1":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"1":{"7":{"7":{"1":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355}}}}},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"1":{"6":{"6":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"e":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"q":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{}}}}}}}}},"u":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"a":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"docs":{}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"\"":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}}}}}},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998}}}}},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998},"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"+":{"1":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.1},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.03985507246376811}},"+":{"docs":{},"=":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"=":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.025968992248062015},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010869565217391304},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.029411764705882353},"Injection.html":{"ref":"Injection.html","tf":0.06329113924050633},"Job.html":{"ref":"Job.html","tf":0.029411764705882353},"Cats.html":{"ref":"Cats.html","tf":0.042416452442159386},"TypedML.html":{"ref":"TypedML.html","tf":0.04838709677419355},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0166358595194085}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.009057971014492754}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005434782608695652}}}},">":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}}},">":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.05141388174807198},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"=":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}},"p":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}},"e":{"docs":{},"l":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005434782608695652},"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"g":{"docs":{},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}},"i":{"docs":{"./":{"ref":"./","tf":0.011461318051575931},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}}},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"s":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"c":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"d":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"n":{"docs":{},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"t":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}},"s":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},".":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"3":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}},"y":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}}},"2":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"(":{"1":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{},"(":{"docs":{},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"[":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"4":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}},")":{"docs":{},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"o":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"i":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"n":{"docs":{},"o":{"docs":{},"y":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"b":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"docs":{}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}},"docs":{}}},"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}},"c":{"docs":{},"k":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"s":{"docs":{},"#":{"5":{"6":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"'":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}},"3":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"t":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.00564516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"s":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0034883720930232558},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"(":{"1":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"docs":{}},"2":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"docs":{}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006201550387596899},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004528985507246377},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.02287581699346405},"Injection.html":{"ref":"Injection.html","tf":0.04113924050632911},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.01532258064516129},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.018484288354898338}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.017191977077363897},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":3.3487574978577546}},"s":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"e":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"[":{"docs":{},"f":{"docs":{},"]":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}},"o":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}},"m":{"docs":{},"t":{"docs":{},"l":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"r":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}}}}}},"o":{"docs":{},"o":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.009302325581395349},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008152173913043478},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03594771241830065},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.028225806451612902},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.022181146025878003}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008527131782945736},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008152173913043478},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012939001848428836}},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"(":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5018115942028984},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.011461318051575931},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008152173913043478},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.013071895424836602},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"x":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984},"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}}}}}},"o":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351817621688227}}}}}},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"o":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"o":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.00564516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"u":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"n":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"p":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Injection.html":{"ref":"Injection.html","tf":2.5126582278481013}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Injection.html":{"ref":"Injection.html","tf":2.5031645569620253}},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}}}}}},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}}}}},"docs":{}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedML.html":{"ref":"TypedML.html","tf":0.008064516129032258}}},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"2":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"1":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"3":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"docs":{}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"3":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"4":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.00564516129032258}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"1":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"3":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"4":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.02005730659025788},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5081521739130435},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"\"":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"/":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"?":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012939001848428836}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}},"y":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.02005730659025788},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}}}}}},"f":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014787430683918669}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Injection.html":{"ref":"Injection.html","tf":0.03481012658227848},"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998},"TypedML.html":{"ref":"TypedML.html","tf":0.013709677419354839},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0196078431372549},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0031007751937984496},"TypedML.html":{"ref":"TypedML.html","tf":0.007258064516129033},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"TypedML.html":{"ref":"TypedML.html","tf":0.028225806451612902},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"]":{"docs":{},"|":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"(":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"/":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}},"_":{"docs":{},".":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.026143790849673203},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"u":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005434782608695652},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.352941176470588},"Injection.html":{"ref":"Injection.html","tf":2.5126582278481013},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"s":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"t":{"docs":{},"i":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006340579710144928},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.013071895424836602},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355}}}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"s":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"i":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"o":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},".":{"docs":{},"g":{"docs":{},".":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"[":{"1":{"5":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"docs":{}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"i":{"docs":{},",":{"1":{"0":{"docs":{},")":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}},"docs":{}},"docs":{}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"$":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}}}}}}},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"t":{"docs":{},"c":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.007712082262210797}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3337209302325577},"TypedML.html":{"ref":"TypedML.html","tf":0.010483870967741936}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.00967741935483871}}}}}}}}},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"w":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"b":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004263565891472868},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"TypedML.html":{"ref":"TypedML.html","tf":0.008870967741935484},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0034883720930232558},"TypedML.html":{"ref":"TypedML.html","tf":0.007258064516129033}}}}}}},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}}}}}}},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006340579710144928},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"c":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.06303724928366762},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3431372549019605},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}}}}}}}}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"?":{"docs":{},"t":{"docs":{},",":{"docs":{},"?":{"docs":{},"c":{"docs":{},"[":{"docs":{},"?":{"docs":{},"a":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"t":{"docs":{},",":{"docs":{},"c":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"c":{"docs":{},"]":{"docs":{},")":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"[":{"docs":{},"t":{"docs":{},",":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"{":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"=":{"docs":{},">":{"docs":{},"f":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"}":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"?":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"?":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"t":{"docs":{},"t":{"docs":{},"]":{"docs":{},"{":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"2":{"docs":{},"@":{"3":{"0":{"docs":{},"c":{"6":{"9":{"docs":{},"a":{"3":{"4":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"4":{"docs":{},"@":{"5":{"5":{"8":{"docs":{},"c":{"6":{"docs":{},"c":{"1":{"7":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},"_":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"4":{"docs":{},"d":{"1":{"docs":{},"c":{"docs":{},"f":{"7":{"docs":{},"a":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"docs":{}}}},"docs":{}}},"6":{"docs":{},"c":{"docs":{},"d":{"2":{"0":{"docs":{},"f":{"docs":{},"a":{"docs":{},"a":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"docs":{}},"docs":{}}}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"@":{"docs":{},"b":{"docs":{},"e":{"7":{"docs":{},"e":{"docs":{},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"docs":{}}}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"@":{"docs":{},"c":{"9":{"7":{"docs":{},"d":{"7":{"4":{"9":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"@":{"6":{"6":{"6":{"docs":{},"b":{"docs":{},"c":{"docs":{},"b":{"docs":{},"e":{"docs":{},"c":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"@":{"1":{"5":{"9":{"docs":{},"b":{"3":{"docs":{},"f":{"1":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"6":{"6":{"docs":{},"b":{"1":{"2":{"docs":{},"f":{"1":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"[":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"@":{"4":{"docs":{},"c":{"6":{"2":{"0":{"docs":{},"c":{"9":{"3":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"2":{"0":{"3":{"5":{"5":{"docs":{},"c":{"2":{"docs":{},"f":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"6":{"docs":{},"e":{"docs":{},"d":{"2":{"docs":{},"d":{"4":{"4":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"docs":{}},"docs":{}}},"docs":{}}}},"docs":{}},"5":{"docs":{},"a":{"0":{"7":{"9":{"7":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},"e":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"o":{"docs":{},"m":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"l":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"f":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},"+":{"2":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"f":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"}":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"[":{"docs":{},"_":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"a":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},".":{"docs":{},";":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"l":{"docs":{},")":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015822784810126583}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}}},"t":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"8":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"docs":{}}},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"b":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}},"o":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"a":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"?":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"o":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"u":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"s":{"docs":{},"(":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"docs":{}},"2":{"0":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"docs":{}},"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}},"?":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"v":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"s":{"docs":{},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.00967741935483871}}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"s":{"docs":{},"/":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}},"docs":{}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.013071895424836602},"Injection.html":{"ref":"Injection.html","tf":0.015822784810126583},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"l":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"docs":{}},"6":{"7":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{}},"docs":{}}}}}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008914728682170543},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01177536231884058},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.016339869281045753},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.032133676092544985},"TypedML.html":{"ref":"TypedML.html","tf":0.008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015822784810126583}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"Injection.html":{"ref":"Injection.html","tf":2.5031645569620253}}},"(":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"n":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"g":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"t":{"docs":{"./":{"ref":"./","tf":10},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.007258064516129033}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"[":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"l":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"f":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"t":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}},"o":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"l":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.013071895424836602}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0196078431372549}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"y":{"docs":{},"r":{"docs":{},"s":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"Job.html":{"ref":"Job.html","tf":10.004201680672269}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"i":{"docs":{},"n":{"1":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}}}}},"2":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.011090573012939002}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"]":{"docs":{},";":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"v":{"docs":{},"m":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"e":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"s":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}}}}},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.011461318051575931}}}}}},"s":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"(":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}}},"s":{"docs":{},"u":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}},"f":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"t":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"0":{"1":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}},"docs":{}},"docs":{}}},"1":{"docs":{},".":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"docs":{}}},"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}},"b":{"docs":{},"c":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"u":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"o":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"a":{"docs":{},"z":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"y":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"r":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"8":{"2":{"docs":{},".":{"5":{"9":{"7":{"0":{"5":{"4":{"8":{"8":{"6":{"2":{"1":{"1":{"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"m":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"r":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998}}}}}}},"n":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"2":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}}}}}}}}}}},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.007712082262210797}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}},"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"docs":{}}}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"2":{"5":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"l":{"docs":{},"e":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"x":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}}},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}}},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}},"f":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"u":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"l":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"TypedML.html":{"ref":"TypedML.html","tf":2.511290322580645}},"\"":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"'":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.011461318051575931},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005426356589147287},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.012096774193548387},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}}}}},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},"e":{"docs":{},"(":{"docs":{},"j":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.02287581699346405},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}},"x":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"t":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"h":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"l":{"docs":{},"l":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"s":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"v":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}}}}}}}}}}}},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},"(":{"1":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},",":{"4":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"c":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"Cats.html":{"ref":"Cats.html","tf":0.010282776349614395}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}},"n":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}}}}}}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.007246376811594203}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3337209302325577}},")":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"$":{"2":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"9":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"0":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"$":{"5":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"5":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"0":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"7":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"8":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"5":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"6":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"1":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"9":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"$":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"1":{"0":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"1":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"2":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"5":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"6":{"1":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"3":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"5":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"4":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"0":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"$":{"docs":{},".":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"$":{"docs":{},"$":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"8":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"1":{"5":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"2":{"1":{"0":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"6":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"7":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"$":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"{":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},".":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"g":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},")":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"u":{"docs":{},"d":{"docs":{},"t":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},")":{"docs":{},",":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"u":{"docs":{},"d":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"8":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"b":{"docs":{},"j":{"docs":{},"#":{"1":{"8":{"0":{"3":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745},"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"l":{"docs":{},"y":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.012096774193548387}},")":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0031007751937984496},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"i":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"n":{"docs":{},"s":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"o":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351817621688227}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355}},"#":{"5":{"5":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"/":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0034883720930232558},"TypedML.html":{"ref":"TypedML.html","tf":0.007258064516129033}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"b":{"docs":{},"y":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"3":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654}}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"4":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"6":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"8":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"2":{"0":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"1":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"i":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010869565217391304}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"i":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}},"(":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519}},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}},"i":{"docs":{},"v":{"docs":{},"o":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005434782608695652}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"t":{"docs":{},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004528985507246377}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"c":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"s":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"d":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"Cats.html":{"ref":"Cats.html","tf":3.33847472150814}},"s":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"i":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}},"a":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004528985507246377}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"[":{"docs":{},"i":{"docs":{},"o":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"u":{"docs":{},"i":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"s":{"1":{"6":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"9":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"2":{"0":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"9":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"3":{"0":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"5":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"5":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"8":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"u":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"#":{"1":{"7":{"7":{"1":{"docs":{},"l":{"docs":{},",":{"docs":{},"j":{"docs":{},"#":{"1":{"7":{"7":{"2":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}},"u":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},"e":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004263565891472868}}},"o":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"f":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"t":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}},"m":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}}},"p":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"y":{"docs":{},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"l":{"docs":{},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"d":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.011461318051575931}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"$":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"3":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"5":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"9":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},".":{"docs":{},"t":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"$":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},">":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},".":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"'":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"(":{"1":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"7":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"9":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"docs":{}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"y":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}},"z":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.022922636103151862},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.010869565217391304},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Job.html":{"ref":"Job.html","tf":0.03361344537815126},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198},"TypedML.html":{"ref":"TypedML.html","tf":2.5080645161290325},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.018484288354898338}},"'":{"docs":{"./":{"ref":"./","tf":0.011461318051575931},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.505434782608696},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},")":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},".":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"[":{"docs":{},"*":{"docs":{},"]":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"[":{"docs":{},"f":{"docs":{},"[":{"docs":{},"_":{"docs":{},"]":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"]":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}},"y":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"g":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0057306590257879654},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedML.html":{"ref":"TypedML.html","tf":0.007258064516129033},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},",":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.012403100775193798},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014787430683918669}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"l":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"q":{"docs":{},"u":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},"#":{"1":{"8":{"8":{"9":{"docs":{},"l":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"#":{"5":{"4":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004263565891472868}}}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"[":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.012605042016806723}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},"i":{"docs":{},"z":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}}},"3":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004528985507246377},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}},"q":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}},".":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"s":{"docs":{},"k":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.00564516129032258}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"l":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"r":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}}},"n":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"a":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.02005730659025788},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.009302325581395349},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.015398550724637682},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3464052287581696},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.02313624678663239},"TypedML.html":{"ref":"TypedML.html","tf":0.016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.027726432532347505}},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.344423906346272}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"p":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0034883720930232558},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.503623188405797},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198},"TypedML.html":{"ref":"TypedML.html","tf":2.504032258064516}},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"docs":{}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}},"docs":{}}}}}}}}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"docs":{}},"\"":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"1":{"2":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"docs":{}},"2":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"7":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"docs":{}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"2":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0189873417721519}}}}}}}}}}}}}}}}},":":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3344961240310074},"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"n":{"docs":{},"[":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}},"u":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301}}}}}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"'":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"s":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}},"s":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"s":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"a":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.013071895424836602}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.005141388174807198}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004263565891472868}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00949367088607595}}},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.008870967741935484}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"e":{"2":{"3":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"docs":{}},"docs":{}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}},"w":{"docs":{},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}},"f":{"1":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"j":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"2":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"j":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}},"t":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}}}}}}}}},"p":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{"./":{"ref":"./","tf":0.02005730659025788},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005434782608695652},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006535947712418301},"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"Cats.html":{"ref":"Cats.html","tf":3.3423307626392456},"TypedML.html":{"ref":"TypedML.html","tf":2.511290322580645},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.009242144177449169}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"'":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}},"d":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.012790697674418604},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.004528985507246377},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.02287581699346405},"Injection.html":{"ref":"Injection.html","tf":0.03481012658227848},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.015424164524421594},"TypedML.html":{"ref":"TypedML.html","tf":0.02338709677419355}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"Cats.html":{"ref":"Cats.html","tf":0.006426735218508998},"TypedML.html":{"ref":"TypedML.html","tf":0.0064516129032258064},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"#":{"1":{"8":{"0":{"5":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}},"o":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.017191977077363897},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0064516129032258064}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.00967741935483871}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"a":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0034883720930232558},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedML.html":{"ref":"TypedML.html","tf":0.0032258064516129032}}}},"y":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},".":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"h":{"docs":{},"y":{"docs":{},"?":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}}},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}},"docs":{}}}}}}}}}}}},"/":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0028653295128939827}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"]":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.008595988538681949},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0027131782945736434},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"]":{"docs":{},"(":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"4":{"2":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"(":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}}},"docs":{}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}},"?":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"s":{"docs":{},"(":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"f":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"}":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"w":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"$":{"docs":{},"\"":{"docs":{},"*":{"docs":{},"\"":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"i":{"docs":{},"\"":{"docs":{},"*":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"1":{"4":{"docs":{},".":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"3":{"7":{"docs":{},"f":{"2":{"3":{"4":{"3":{"0":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}}}}}}},"'":{"docs":{},"`":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}},"x":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"`":{"docs":{},"i":{"docs":{},"`":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"_":{"4":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}},"q":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"z":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"*":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"TypedML.html":{"ref":"TypedML.html","tf":0.014516129032258065}},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"*":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"'":{"docs":{},"_":{"2":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"_":{"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"docs":{}}}}}}},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002325581395348837}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.13178294573643412},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.12047101449275362},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.032679738562091505},"Injection.html":{"ref":"Injection.html","tf":0.06645569620253164},"Job.html":{"ref":"Job.html","tf":0.025210084033613446},"Cats.html":{"ref":"Cats.html","tf":0.05398457583547558},"TypedML.html":{"ref":"TypedML.html","tf":0.056451612903225805},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},":":{"2":{"0":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"3":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"5":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"9":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186}}}},"docs":{}},"3":{"0":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}}},"1":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"5":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}}}},"7":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.004032258064516129}}}},"9":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}},"4":{"4":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"6":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"7":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}},"docs":{}},"5":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599}}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0011627906976744186},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826},"Cats.html":{"ref":"Cats.html","tf":0.02313624678663239}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"[":{"1":{"docs":{},".":{"0":{"docs":{},",":{"2":{"docs":{},".":{"0":{"docs":{},",":{"3":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0008064516129032258}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{},".":{"docs":{},".":{"1":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}},"docs":{}},"docs":{}}}}},"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}},"x":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"_":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.003875968992248062},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}}},"docs":{}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"#":{"5":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005426356589147287}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"5":{"0":{"0":{"7":{"1":{"5":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"4":{"3":{"6":{"2":{"9":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}},"]":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015}}}},"a":{"docs":{},"]":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633}}}}}},"i":{"docs":{},"#":{"1":{"7":{"7":{"1":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},",":{"docs":{},"j":{"docs":{},"#":{"1":{"7":{"7":{"2":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.002717391304347826}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0036231884057971015},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0032679738562091504}}},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"[":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}}}}}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"1":{"7":{"7":{"1":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.010483870967741936}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0024193548387096775}}}}}}}}}}}},"^":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004651162790697674},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005434782608695652},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.00980392156862745},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedML.html":{"ref":"TypedML.html","tf":0.004838709677419355}}},"_":{"1":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004263565891472868},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}},"#":{"1":{"8":{"7":{"6":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0031007751937984496},"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994},"TypedML.html":{"ref":"TypedML.html","tf":0.0016129032258064516}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004263565891472868}}}},"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}}}},"4":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}},"{":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.012658227848101266},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002570694087403599},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}},"|":{"1":{"0":{"0":{"0":{"docs":{},"|":{"1":{"0":{"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"3":{"3":{"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"7":{"6":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"6":{"2":{"docs":{},".":{"8":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"9":{"0":{"8":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"1":{"2":{"docs":{},".":{"5":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"8":{"docs":{},"|":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.01744186046511628},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.008152173913043478}},"[":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"4":{"5":{"docs":{},",":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"8":{"3":{"docs":{},",":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"2":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"7":{"4":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"3":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"1":{"0":{"0":{"docs":{},",":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"2":{"5":{"docs":{},",":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"]":{"docs":{},"|":{"docs":{},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}},"5":{"0":{"docs":{},",":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"|":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015503875968992248}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.001937984496124031}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0007751937984496124}}},"b":{"docs":{},"c":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}},"+":{"docs":{},"|":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0038560411311053984}}}}},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0003875968992248062},"Injection.html":{"ref":"Injection.html","tf":0.006329113924050633},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0031645569620253164}}}},"&":{"docs":{},"&":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0018115942028985507}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}},"`":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},"`":{"docs":{},")":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}}}}}}}}}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0009057971014492754}}}},"y":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0012853470437017994}}}}}},"?":{"docs":{},"?":{"docs":{},"?":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"length":3292},"corpusTokens":["\"\",","\"0.5.0\"","\"abc\")","\"another\")))","\"dummy\"","\"e\")","\"false\")","\"frameless","\"java.util.date\",","\"jday\")","\"lyon\",","\"mydate\"","\"org.typelevel\"","\"paris\")","\"paris\",","\"q\")","\"s\"))))","\"s\",","\"san","\"string\"),","\"task2\"","\"unique\"","\"w\")","$\"*\".","$\"i\"*2)","$anon$1@37f23430","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","%","%%","&&","'(sum(`i`)","').map(r","'_4)","'`citi`'","'`i`'","'`x`'","'city),","'name),","'population)","'price),","'project","'q',","'s)","'x',","'z'))","'z'.","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(((((((((","(0","(0,0,0)","(1,","(1,2,3)","(10,9,9)","(2,","(8,","(8,2,3)","(a","(and","(apttypedds)","(apttypedds2)","(case","(chris,map(0","(class:","(column:","(e.g.","(e.g.,","(empti","(enjoy","(frameless.typedcolumn[(string,","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(from","(i","(i#1771l","(if","(implicit","(in","(includ","(int,","(isnotnull(i#1771l)","(john,map(0","(look","(lyon,166500.0))","(name","(name:","(or","(paris,333333.3333333333),","(peopl","(phonebooktf:","(repres","(sam,map(0","(sample:","(see","(semigroup)","(seq[(int,","(string,","(such","(the","(thumb","(u:","(up","(what","(which","(with","(wrappedarray((1,string)),2)",")","))",").as[apartmentdetails]",").as[aptpricecity].show().run",").as[stats].show().run()",").show().run()",").show(1).run()",").show(2).run()","*","*deserializetoobject","*filescan","*filter","*mapel","*project","*serializefromobject","+","++=","+1,",",","...","...).",".ac",".appli",".as[family]()",".as[housedatawithfeatures]",".as[neighborhoodcount]()",".dataset",".desc.",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select($\"*\",",".select('_2,",".select('neighborhood)",".sortdesc('count)","/","//","0)))","0.0|","0.0|325000.0|","0.13.13:","0.2,","0.4.0","0.4.1","0.5.0","1","1)","1))","1)),","1),","1,","1.0","1.0.0","1.0.1","1.1|","1.6","1.6+,","1.6,","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10).select(fds('i)).explain()","10).select(fds('i)).show().run()","10).select(fds('x))","10,","100)","100,","10000.0,","100000)))","100000),","102|","10|","11","11))","12)","12,","133000.0,","133000.0|","15)))","15:18:58","18","1:","1|","1|250000.0|","2","2)","2)#1890l]","2))","2)),","2),","2).as[updatedsurface]","2).show().run()","2,","2.0","2.0)","2.0,","2.10,","2.11","2.11,","2.11.x.","2.2.0","2.2.1","2.3.2.","20%","20)","20,","200000),","200000.0,","200000.0|","2018))","22.","2229621),","2229621|","2409.6385542168673,","25,","250000),","250000.0,","250000.0|","250|","25|[paris,","27|","2955.5555555555557,","2:","2|","2|300000.0|","2|[a,","3","3)","3))","3),","3,","300000.0,","300000.0|","32,","325000.0,","325000.0|","343629)","343629|","3|","3|450000.0|","3|[a,","4","4))","4)),","4,","430","4391.891891891892)","4391.891891891892|","45,","4500.0,","450000.0,","450000.0|","450|","454","45|133000.0|","47|","5,","50,","500000)","500000),","500715),","500715|","500|","52|","6,","6833.333333333333|","74,","740|","76|","770","800000)))","83,","830|","83|200000.0|","854","85|","900000)",":",":)",":20:",":23:",":24:",":25:",":26:",":27:",":28:",":29:",":30:",":31:",":35:",":36:",":37:",":39:",":44",":46",":47",":50","::",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","==","===","=>",">",">=","???","['citi]","['x]","[1...10]).","[1.0,2.0,3.0]","[],","[_1:","[a]frameless.typedcolumn[foo,a]","[age:","[city#53,","[city,","[city:","[features:","[i#1771l","[i#1771l,j#1772]","[i#1771l]","[i,","[i:","[input[0,","[isnotnull(i),","[lyon,500715]|","[nice,343629]|","[out,","[out]frameless.typedaggregate[foo,out]","[ratio:","[squarefeet:","[sum(i#1771l)","^","_1#1876l]","_1|","_2:","_2|","_3|","_4|","`sum(i)`)'","a)(implicit","a):","ab","abil","abov","above)","above,","above.","abstract","accept","access","accident","achiev","act","action","action[(seq[(int,","action[t]","actual","ad","add","addit","address","address,","address:","adelbertc","adjustedpric","adjustedprice.show().run()","adjustedprice:","aforement","again","against","agg()","agg(avg(aptds('price))).","aggreg","aggregated,","agree.","algebra","alia","alias","align","align.","allcities:","allcities|","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","allowed,","allowed:","along","alphabet:","alternatively,","alternatives:","amount","and/or","anna","annotate/nam","annoy","anoth","another,","anyth","apach","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartment.","apartmentdetail","apartmentdetails(city:","apartmentdetails?","apartmentshortinfo","apartmentshortinfo(city:","apartmentshortinfo?","api","api,","api.","apis),","apis.","appear","append","appli","applic","applications.","apply(a:","apply(d:","approach","approxim","aptd","aptds('city),","aptds('price)","aptds('price)))","aptds('price),","aptds('surface),","aptds('surface).cast[double]","aptds('surface).cast[double])","aptds.","aptds.agg(","aptds.select(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)","apttypedds('city)).as[updatedsurface]","apttypedds('city).asc,","apttypedds('city).cast[double]","apttypedds('price).desc","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.joininner(citiinfotypedds)","apttypedds.makeudf(pricemodifier)","apttypedds.orderby(","apttypedds.orderby(apttypedds('city).asc).show(2).run()","apttypedds.project[apartmentshortinfo]","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds.union(apttypedds2).show().run","apttypedds2","apttypedds2('price)","apttypedds2('price)).","apttypedds2.drop[citybeds]","apttypedds2.droptupled('price):","apttypedds2.union(apttypedds).show().run","apttypedds2.withcolumnreplaced('price,","apttypedds2.withcolumntupled(","apttypedds2.withcolumntupled(lit(array(\"a\",\"b\",\"c\"))).show(2).run()","apttypedds2:","apttypedds:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","are:","area","argument","arguments)","arithmet","ariti","arity.","around","array","array((joe,map(0","array(1,","array[(username,","array]","arraycontains(t('_1),","arraycontains(t('_2),","arraycontains:","as:","as[bedroomstats]","as[long]","as[t]","ascol()","ascol(),","assembl","assembler.transform(testdata).as[housedatawithfeatures]","assembler.transform(trainingdata)","assembler.transform(trainingdata).as[housedatawithfeatures]","assembler.transform(trainingdata).as[wronghousefeatures]","assembler.transform(wrongtrainingdata)","assembler:","associ","assum","avail","available,","available.","averag","averaging,","avg","avg(aptds('price))","avg(aptds('price)),","avg(aptds('surface))","avg(aptds('surface)),","avg,","avgprice:","avgpricebeds1:","avgpricebeds2:","avgpricebeds3:","avgpricebeds4:","avgprice|","avgsurface:","avgsurface|minsurface|","avoid","away:","b","b):","b,","b.","b:","b]","back","bar","bar(1)))","bar(1.1,","bar(d:","bar(i:","bar)","bardate(1.1,","bardate(d:","bardate)","base","batched:","be","bedroom","bedrooms#56]","bedrooms.","bedrooms:","bedrooms];;","bedroomstat","bedroomstats(","bedroomstats('avgpricebeds2).getorelse(0.0),","bedroomstats('avgpricebeds3).getorelse(0.0))","bedroomstats(lyon,some(133000.0),some(200000.0),none,none)","bedroomstats(nice,none,none,some(325000.0),none)","bedroomstats(paris,some(250000.0),some(300000.0),some(450000.0),none)","bedroomstats.collect().run().foreach(println)","bedroomstats.select(","bedroomstats.show().run()","bedroomstats:","before.","behav","below","benefit","besid","bestneighborhood","better","between","bigint","bigint))","bigint,","bigint]","bind","birthday:","block","boolean","boolean)","boolean):","boolean)]","boolean)].","boolean,","boolean:","bootstrap","both","break","bring","bug","build.sbt","built","bulletproof:","c","c('_2)).show(2).run()","c,","c.","c.select(c.colmany('_1,","c.show(1).run()","c:","c]|","calcul","call","caller","calls,","can't","can't,","capabl","captur","care","case","case)","case.","cast","cast(10","cast(2","cast,","cat","catalyst","catalystcast.","catalystcast[string,","catch","categor","cats\"","cats,","cats.","cats.data.readert","cats.effect.implicits._","cats.effect.io","cats.effect.sync","cats.effect.sync[f].","cats.implicit","cats.implicits._","cats.mtl.implicits._","cats:","caught","caus","chang","channel","check","choos","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name)","city.","city:","cityb","citybeds(city:","citybeds(lyon,2))","citybeds(paris,1))","citybeds(paris,1),","citybeds(paris,3))","citybeds(paris,3),","citybeds.","citybeds.head(3).run()","citybeds.headoption.run()","citybeds.limit(4).collect().run()","citybeds.select(citybeds.ascol,","citybeds.take(2).run()","citybeds:","citybedsoth","citybedsother(city:","cityindexed:","cityinfo","cityinfo(city:","citymapentry(","citymaptf:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.select(cityratio('city),","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|avgpricebeds1|avgpricebeds2|avgpricebeds3|avgpricebeds4|","city|bedrooms|","city|surface|","class","class:","classes)","classes.","clause.","clearli","click","close","closur","closures.","cmax","cmin","code","code.","collect","collect())","collection,","collectset(aptds('city))","colmany()","column","column(s)","column(s).","column,","column.","column:","columnar","columns)","columns,","columns.","columns:","combin","come","common","commonli","companion","compar","comparison","comparison,","compat","compil","compile)","compile,","compile.","compile:","compiles:","complet","complex","compos","composit","comprehens","compromis","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","concat,","concept:","condition","conduct","conf","confus","consid","consist","consol","construct","constructor","contain","content","context","continu","contrari","contribut","contributor","conveni","convert","correct","correct.","correctli","correspond","count","count,","count:","countandtakejob","counterpart","coupl","creat","csum,","current","custom","customizable,","d.gettime()","d:","d]|true|","data","data)","data,","data.","data:","datafram","dataframe,","dataframes,","dataset","dataset\"","dataset,","dataset.","dataset/datafram","dataset:","dataset?.","dataset[daterange]","dataset[long].","datasets,","datawithfeatur","datawithfeatures:","daterange(s:","datetolonginject","datetolonginjection:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","deal","decod","def","default","defin","definit","delay","depend","deprec","deriv","derived,","descript","description.","description:","design","detail","detail.","detect","develop","differ","different,","direct","directli","discuss","discussion.","disk","distinguish","dive","divid","document","document.","domain","don't","done","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","drop","drop().","drop/replace/add","droptupled()","ds","ds.collect()","ds.filter($\"i\"","ds.filter(_.i","ds.select(sum($\"i\"),","ds.show()","ds:","due","e.g.,","e:","each","earli","easi","easier","easili","effect","effect:","effects.","element","elements.","elements:","elid","empti","empty,","emptyrdd","emptyrdd[15]","encod","encoder,","encoder.","encoder:","encoders,","enhanc","enough","enrich","ensur","entir","environ","equalto(i,10)],","equival","error","error)","error.","error:","essenti","estimator.","estimators.","etc)","etc.","everyth","evid","evidence$1:","exactli","exampl","example,","example.","example:","except","exclus","execut","exist","expect","expected:","expens","explain","explan","explicit","explicitli","expos","express","expression'","extend","extra","extrem","e|","f","f.neighborhood))","f.residents.split('","f[_]","f[_],","f[a]","f[a],","fact","fail","failure:","false,","false]","familiar","family(residents:","family:","fanci","fd","fds('i)).show().run()","fds.agg(fsum(fds('i))+22).show().run()","fds.agg(fsum(fds('i)),","fds.filter(fds('i)","fds.select(fsum(fds('i)))","fds:","featur","features(price:","features(squarefeet:","features).","features):","features.","features:","feb","feed","feel","femal","few","field","field]","fields.","fields]","file","file.","filter","filter(conditionexpr:","filteredd","filteredds.explain()","filteredds.show()","filteredds:","finaljob","finaljob.","finaljob:","finally,","find","first","first()","first,","first_value)","fit","five","flat","focu","follow","follows:","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo(s:","foo,","foo.","foodate(i:","footag","footage.","forest,","form","formal","format","format:","found","found:","frameless","frameless'","frameless,","frameless.","frameless._","frameless.abstracttypedcolumn[?t,?c[?a]]","frameless.abstracttypedcolumn[t,c[a]]","frameless.abstracttypedcolumn[t,c[a]],","frameless.catalystcast[string,double]","frameless.catalystcollection[c])column.thistype[t,boolean]","frameless.catalystdivisible[double,out],","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.cats.implicits.","frameless.cats.implicits._","frameless.cats.implicits._.","frameless.cats.outer._","frameless.functions._","frameless.functions.aggregate._","frameless.functions.aggregate.{sum","frameless.functions.aggregate.{sum=>fsum}","frameless.functions.lit","frameless.functions.nonaggregate._","frameless.functions.nonaggregate.when","frameless.injection$$anon$1@4d1cf7ad","frameless.injection$$anon$1@6cd20faa","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.job","frameless.job$$anon$2@30c69a34","frameless.job$$anon$4@558c6c17","frameless.job[int]","frameless.job[seq[foo]]","frameless.job[seq[int]])frameless.job[int]","frameless.ml._","frameless.ml.appendtransformer[rfinputs,frameless.ml.classification.typedrandomforestclassifier.outputs,org.apache.spark.ml.classification.randomforestclassificationmodel]","frameless.ml.appendtransformer[rfinputs,frameless.ml.regression.typedrandomforestregressor.outputs,org.apache.spark.ml.regression.randomforestregressionmodel]","frameless.ml.appendtransformer[stringindexerinput,frameless.ml.feature.typedstringindexer.outputs,org.apache.spark.ml.feature.stringindexermodel]","frameless.ml.classification._","frameless.ml.classification.typedrandomforestclassifier@be7ee","frameless.ml.classification.typedrandomforestclassifier[rfinputs]","frameless.ml.feature._","frameless.ml.feature.typedindextostring@c97d749","frameless.ml.feature.typedindextostring[indextostringinput]","frameless.ml.feature.typedstringindexer@666bcbec","frameless.ml.feature.typedstringindexer[stringindexerinput]","frameless.ml.feature.typedvectorassembler@159b3f1","frameless.ml.feature.typedvectorassembler@66b12f1","frameless.ml.feature.typedvectorassembler[features]","frameless.ml.regression._","frameless.ml.regression.typedrandomforestregressor@4c620c93","frameless.ml.regression.typedrandomforestregressor[rfinputs]","frameless.ml.typedestimator$$anonfun$fit$1$$anon$1@20355c2f","frameless.ml.typedestimator$$anonfun$fit$1$$anon$1@36ed2d44","frameless.ml.typedestimator$$anonfun$fit$1$$anon$1@5a0797","frameless.ops.as[(double,","frameless.ops.as[(string,","frameless.syntax._","frameless.typedaggregate[foo,?]","frameless.typedcolumn[(string,","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[foo,?]","frameless.typedcolumn[tt,double])(implicit","frameless.typeddatafram","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(citybeds,","frameless.typeddataset[(double,","frameless.typeddataset[(int,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[apartmentshortinfo]","frameless.typeddataset[bedroomstats]","frameless.typeddataset[citybeds]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[foo]","frameless.typeddataset[housecityprediction]","frameless.typeddataset[housecitypredictionindexed]","frameless.typeddataset[housecitypredictioninputs]","frameless.typeddataset[housedata]","frameless.typeddataset[housedatawithfeatures]","frameless.typeddataset[housedatawithfeaturesandindex]","frameless.typeddataset[housepriceprediction]","frameless.typeddataset[int]","frameless.typeddataset[person]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[updatedsurface]","frameless.typeddataset[wronghousedata]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless.typedencoder[mydate]","frameless.typedencoder[out],","frameless.typedencoder[person]","frameless.with[apartment,tt]{typ","frameless:","framelessvers","framelessversion,","francisco\",","francisco)","free","friend.","friendli","from)","fsum}","full","fulli","function","function(s)","function.","function:","functions.","functions:","further","futur","g8","garden","gender","gender)","gender:","gendertoint:","gener","general).","generated.","get","get.;;","getorelse().","giter8","github,","gitter","gitter)","give","given","go","goal","goal:","goe","great!","ground,","group","groupbi","groupby()","groupby(aptds('city)).","guard","handhold","handl","hasgarden","hasgarden:","have","help","help?","here","here.","hierarchi","hold","hood,","hous","housecitypredict","housecityprediction(","housecitypredictionindex","housecitypredictionindexed(","housecitypredictioninput","housecitypredictioninputs(features:","housedata","housedata(100,","housedata(150,","housedata(20,","housedata(200,","housedata(50,","housedata(squarefeet:","housedata?","housedatawithfeatur","housedatawithfeatures(squarefeet:","housedatawithfeaturesandindex","housedatawithfeaturesandindex(","housepricepredict","housepriceprediction(","however,","http://opensource.org/licenses/apach","i.","i:","id","ident","if(nam","ignor","imario","imarios/frameless.g8","implement","implicit","implicitli","implicits.scala:42","implicits.scala:67","import","improv","inabl","includ","incompat","index","indexeddata","indexeddata:","indexedpredict","indexedpredictions:","indexedtestdata","indexedtestdata.project[housecitypredictioninputs]","indexedtestdata:","indexer.fit(datawithfeatures).run()","indexer:","indexermodel","indexermodel.transform(datawithfeatures).as[housedatawithfeaturesandindex]","indexermodel.transform(testdatawithfeatures).as[housedatawithfeaturesandindex]","indexermodel:","indextostr","indextostring.transform(indexedpredictions).as[housecityprediction]","indextostring:","indextostringinput","indextostringinput(predictedcityindexed:","inflat","inflation.show(2).run()","inflation:","inform","initi","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","inmemoryfileindex[file:/tmp/foo],","input","insid","instal","instanc","instance.","instances:","instanti","instead","instead.","int","int)","int).","int)]","int,","int.","int]","integr","intention","interest","intermedi","intern","introduc","introduct","intuitively,","invalid","invert(b:","invert(l:","io","issues.","issues/questions.","it'","it.","i|","j.","j:","j];;","jar.","java.lang.unsupportedoperationexception:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date(system.currenttimemillis))))","java.util.date)","java.util.date))","java.util.date)))","java.util.date))))","java.util.date).gettime(),","java.util.date):","java.util.date,","java.util.date.","jeremyrsmith","job","job,","job[a]","job[int]","job[seq[int]]):","jobs.","joe","join","join1(tf1:","join2(tf1:","joins,","jvm","j|","kanterov","keep","kernel","key","key.","keys.","know","label","label)","label):","label,","languag","larg","last","layer","lazi","lazili","lazy,","lazy.","lead","learning.","less","let","let'","letter","level","leverag","librari","library:","librarydepend","licens","lift","like,","limit","limitations.","line","linux","list","list(","list(person(42,male))","list(person(42,sun","list[string])","list[string]),string]","list[string]),string],","list[string])]","lit(0.001))","lit(1.1)).","lit(list(\"a\",\"b\",\"c\")))","lit(list(\"abc\",\"c\",\"d\")))","litaggr(\"hello","liter","load","local","localrel","locat","location:","long","long)","long)))","long):","long)]","long)])","long,","long:","long]","look","loos","lowest","lyon]|","lyon|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","mac","machineri","macro","made","main","maintain","make","makerdd","male","male))","manag","mani","manipul","manner.","map","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[25]","mapvalu","match","materialize.","math","matrices.dense(2,","matrix","matrix))","matrix:","matrix]","matrixd","matrixds:","matter","max,","meaning","mechan","member","members.","mention","merg","messag","method","method,","method.","mf","min\").","min(aptds('surface)),","min(aptds('surface)).cast[double],","min,","minim","minimum","minsurface:","mirror","mismatch;","miss","missing,","misspel","mistak","mix","ml","ml\"","ml'","model","model.","model.transform(testdata)","model.transform(testdatawithfeatures)","model.transform(testdatawithfeatures).as[housepriceprediction]","model.transform(testinput).as[housecitypredictionindexed]","model:","moder","modifi","modul","module,","modules:","monad","more","moreover,","mtl","much","mydat","mydate(jday:","n","n:","name","name.exists(set('x',","name:","namely,","names,","names/typ","names/types,","natur","need","needed:","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","neighborhoods:","nest","new","newinstance(class","next","next,","nice,","nice|","nice|325000.0|","nil","nil)","nlplib","nlplib.uniquename(p.name)","non","none","none).","normal","not,","not.","note","noth","notifi","now","now,","null|","number","number,","numer","obj#1803:","obj#1804:","object","object.","obtain","obviou","of)","offer","offici","often,","ok","olivierblanvillain","on","on(1,2,3,4).","onc","ontypeddataframe.","onward.","open","oper","operation.","operations,","operations:","optim","optimizer)","option","option.","option[citybeds]","option[double])","option[double],","order","order.","org.apache.spark.ml.linalg._","org.apache.spark.ml.linalg.matrix","org.apache.spark.ml.linalg.matrix)]","org.apache.spark.ml.linalg.matrix:","org.apache.spark.ml.linalg.matrixudt.","org.apache.spark.ml.linalg.vector","org.apache.spark.ml.linalg.vector),wronghousefeatures]","org.apache.spark.ml.linalg.vector)]","org.apache.spark.ml.linalg.vectorudt","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","org.apache.spark.sql,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.analyzer.failanalysis(analyzer.scala:91)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$2.applyorelse(checkanalysis.scala:88)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$apply$9.apply(checkanalysis.scala:280)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$checkanalysis$class$$anonfun$$checkvalidaggregateexpression$1$5.apply(checkanalysis.scala:253)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:280)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.apply(checkanalysis.scala:85)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.org$apache$spark$sql$catalyst$analysis$checkanalysis$class$$anonfun$$checkvalidaggregateexpression$1(checkanalysis.scala:239)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$checkanalysis$1.org$apache$spark$sql$catalyst$analysis$checkanalysis$class$$anonfun$$checkvalidaggregateexpression$1(checkanalysis.scala:253)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.checkanalysis(checkanalysis.scala:78)","org.apache.spark.sql.catalyst.analysis.checkanalysis$class.failanalysis(checkanalysis.scala:39)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:71)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$6.apply(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1$1.apply(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan$$anonfun$transformexpressionsup$1.apply(queryplan.scala:268)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:298)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:289)","org.apache.spark.sql.catalyst.plans.queryplan.org$apache$spark$sql$catalyst$plans$queryplan$$recursivetransform$1(queryplan.scala:293)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:279)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:268)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1$$anonfun$10.apply(scalareflection.scala:614)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1$$anonfun$10.apply(scalareflection.scala:626)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1.apply(scalareflection.scala:455)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1.apply(scalareflection.scala:614)","org.apache.spark.sql.catalyst.scalareflection$$anonfun$org$apache$spark$sql$catalyst$scalareflection$$serializerfor$1.apply(scalareflection.scala:632)","org.apache.spark.sql.catalyst.scalareflection$.cleanupreflectionobjects(scalareflection.scala:39)","org.apache.spark.sql.catalyst.scalareflection$.org$apache$spark$sql$catalyst$scalareflection$$serializerfor(scalareflection.scala:455)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:444)","org.apache.spark.sql.catalyst.scalareflection$class.cleanupreflectionobjects(scalareflection.scala:809)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:70)","org.apache.spark.sql.catalyst.trees.treenode$$anonfun$transformup$1.apply(treenode.scala:289)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:127)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:187)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:288)","org.apache.spark.sql.datafram","org.apache.spark.sql.dataset","org.apache.spark.sql.dataset$.ofrows(dataset.scala:67)","org.apache.spark.sql.dataset.(dataset.scala:165)","org.apache.spark.sql.dataset.(dataset.scala:171)","org.apache.spark.sql.dataset.org$apache$spark$sql$dataset$$withplan(dataset.scala:2884)","org.apache.spark.sql.dataset.select(dataset.scala:1150)","org.apache.spark.sql.dataset.select(dataset.scala:1210)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:275)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:52)","org.apache.spark.sql.functions.sum","org.apache.spark.sql.lowprioritysqlimplicits$class.newproductencoder(sqlimplicits.scala:233)","org.apache.spark.sql.sparksess","org.apache.spark.sql.sqlcontext","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:33)","org.apache.spark.sql.types.userdefinedtype[a]","org.apache.spark.{sparkconf,","origin","os","other:","otherwise(lit(0.0))).show(8).run()","other|","out","outer","over","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","overflow","overhead","overload","overview","overview):","p","packag","pair","parallelcollectionrdd[14]","parallelcollectionrdd[16]","parallelcollectionrdd[18]","parallelcollectionrdd[20]","parallelcollectionrdd[21]","paramet","parquet","parquet,","part","partial","particular","partitionfilters:","pass","peopl","people:","per","perform","performance.","perhap","person","person(age:","person(name:","person(r,","persond","personds:","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","physic","pivot","pivot(aptds('bedrooms)).","pivot,","place","plain","plan","plan,","plan.","plan:","pleas","point,","polymorph","popul","popular","population:","possibl","potenti","practic","pre","precis","predicates.","predict","predict).","predictedcity:","predictedcityindexed.","predictedcityindexed:","predictedprice:","predictions.select(predictions.col('predictedcity)).collect.run()","predictions.select(predictions.col('predictedprice)).collect.run()","predictions:","prefer","preserv","previou","previous","price","price#55,","price,","price/surfac","price:","price:double)","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","price|bedrooms|","primit","println(data.cmax)","println(data.cmaxoption)","println(data.cmin)","println(data.cminoption)","println(data.csum)","println(data.csumoption)","probability:","probabl","problem","problem.","problemat","process","product","product,","product.","program","program,","programm","project","project,","project:","projectio","projections/selections.","proof","properli","prove","provid","pst","public","pull","pushedfilters:","queri","question","quick","q|","r","rais","random","ratio","ratio:","ratio|","rawprediction:","rdd","rdd.","rdd:","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","rdds,","read","readability.","readabl","readert","readert[io,","readi","readschema).","readschema:","reasons,","recurs","reducebykey","refer","referenc","reflect","relation[i#1771l,j#1772]","releases.","remind","repl\").set(\"spark.ui.enabled\",","replac","repres","represent","request","requests)","requests.","requir","required:","res16:","res17:","res19:","res20:","res27:","res28:","res29:","res2:","res30:","res35:","res5:","res6:","res8:","residents:","resolut","resolv","result","result.","result.run(spark).unsaferunsync()","result:","resultwithdescription.run(spark).unsaferunsync()","resultwithdescription:","rethought","retriev","return","reus","rf","rf.fit(indexeddata).run()","rf.fit(trainingdatawithfeatures)","rf.fit(trainingdatawithfeatures).run()","rf.fit(wrongtrainingdatawithfeatures)","rf:","rfinput","rfinputs(cityindexed:","rfinputs(price:","rfinputs.","right","right?","root","row","run","run()","run:","runtim","runtime.","s:","sadly,","safe","safe,","safe.","safeti","safety!","safety,","safety.","sale","same","sampl","sample.map(_.min)","samplestat","samplestats.show().run()","samplestats:","save","say,","sbt","sc.emptyrdd","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala","scala.","scala.collection.abstracttraversable.map(traversable.scala:104)","scala.collection.immutable.list.flatmap(list.scala:355)","scala.collection.immutable.list.foreach(list.scala:392)","scala.collection.immutable.list.map(list.scala:296)","scala.collection.immutable.sortedmap","scala.collection.immutable.sortedmap[string,int])]","scala.collection.map[string,scala.collection.immutable.sortedmap[string,int]]","scala.collection.map[user,transactioncount]","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:48)","scala.collection.mutable.resizablearray$class.foreach(resizablearray.scala:59)","scala.collection.traversablelike$$anonfun$flatmap$1.apply(traversablelike.scala:241)","scala.collection.traversablelike$$anonfun$map$1.apply(traversablelike.scala:234)","scala.collection.traversablelike$class.flatmap(traversablelike.scala:241)","scala.collection.traversablelike$class.map(traversablelike.scala:234)","scala.reflect.internal.tpe.typeconstraints$undolog.undo(typeconstraints.scala:56)","scala>","scalareflect","schema","schema.","seal","second","second,","secondari","section","see","see,","seem","select","select()","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","selectmany()","selectmany,","semigroup","sense,","separately,","seq(","seq(person(42,","seq[(string,","seq[citybeds]","seq[double]","seq[person]","seq[string]","sequenc","serial","serializ","serv","set","sever","shadow","shapeless","shapeless'","shapeless.hlist","shapeless.tag.tagged[string(\"citi\")]","shapeless.tag.tagged[string(\"x\")]","shell","shorter","show","show()","show(1).run()","showcas","shown","shuffledrdd[17]","shuffledrdd[19]","sign","signatur","signatures:","similar","similar)","similarly,","simpl","simpli","simplifi","simplist","simply:","singl","situat","size","skip","slow","small","snippet,","solut","solv","some(citybeds(paris,2))","sort","sortedmap(\"task1\"","sortedmap(\"task3\"","sorting.","sourc","spark","spark'","spark).","spark,","spark.","spark.createdataset(","spark.createdataset(apartments)","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark.sparkcontext.setloglevel(\"warn\")","spark:","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparkdelay","sparkdelay[f[_]]","sparkdelay[f].","sparksess","sparksession,","sparksession.","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","sqlcontext","sqlcontext):","sqlcontext.createdataset(seq(daterange(new","squar","squarefeet:","stack","stack.","stack:","stage","standard","start","stat","statement","statement).","stats(","stay","still","store","strict","string","string(\"abc\")","string)","string),updatedsurface]","string):","string)]","string)])","string)],","string,","string.","string]","stringindexerinput","stringindexerinput(city:","strongli","struct","struct,","struct]","structur","subsequ","subset","such","suffici","suggests,","sum","sum(i)#1889l,","sum,","summari","suppli","support","suppos","surfac","surface#54,","surface,","surface:","suspend","suspended.","suspens","symbol","syntax","syntax.","syntax:","syntaxes.","system","systems,","t","t.withcolumntupled(","t:","t]","tabl","table,","tables:","take","target","task","task2","task3","tdataframe[schema","tdataframe[schema]","techniqu","tell","ten","term","test","test.","testdata","testdata.","testdata:","testdatawithfeatur","testdatawithfeatures:","testinput","testinput:","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","thank","then,","therefore,","thing","this.","those","thread","three","through","thunk","time","time,","time.","time:","timeseri","timeseries)]","togeth","together.","top","totalperus","totalperuser.collectasmap","totalperuser:","toy","trace):","trace,","track","track,","train","trainingdata","trainingdata:","trainingdatawithfeatur","trainingdatawithfeatures:","trait","transactioncount","transactioncount)]","transform","transformations.","tri","troubl","true,","tt,","tupl","tuple23","tutori","two","two.","type","type,","type.","type:","type;","typeclass","typeclass,","typeclass:","typedaggreg","typedcolumn","typedd","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry])","typeddataframe[citymapentry].","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","typeddataset","typeddataset'","typeddataset,","typeddataset.","typeddataset.create(1","typeddataset.create(apartments)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset.create(ds)","typeddataset.create(people)","typeddataset.create(seq(","typeddataset.create(seq(\"label\"","typeddataset.create(seq((1,","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset.create(seq(housedata(120,","typeddataset.create(seq(housedata(20,","typeddataset.create(seq(housedata(70,","typeddataset.create(seq(mydate(new","typeddataset.create(seq(wronghousedata(20,","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[(string,int)]","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[apartmentshortinfo]","typeddataset[citybeds]","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeddataset[string]","typeddataset[t]","typeddataset[tuplen[...]]","typeddataset[u]","typeddatasets.","typedds:","typedencod","typedencoder[a]","typedestim","typedestimator,","typedestimators,","typedindextostr","typedindextostring[indextostringinput](indexermodel.transformer.labels)","typedrandomforestclassifi","typedrandomforestclassifier.","typedrandomforestclassifier[rfinputs]","typedrandomforestregressor","typedrandomforestregressor.","typedrandomforestregressor[rfinputs]","typedrandomforestregressor[wrongrfinputs]","typedstringindex","typedstringindexer[stringindexerinput]","typedtransform","typedtransformercan","typedvectorassembl","typedvectorassembler[features]","typedvectorassembler[wrongfeatures]","typeencod","typelevel","types)","types,","types.","types:","typesaf","typesafeti","typo","typo,","u","udf","udf(aptds('city),","udf:","ui","unabl","under","underli","unfortunately,","union","uniqu","uniquename(name:","unit:","unlik","unsaf","up","up,","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","user","user'","usernam","usual","util","val","valid","valu","value#1805l]","value,","value.","value:","vanilla","variabl","variou","vector","vector)","vector))","vector,","vector:","vector[string])","vector]","vectorassembl","vectorassembler)","vectorassembler.transform(testdata).as[housedatawithfeatures]","vectorassembler.transform(trainingdata).as[housedatawithfeatures]","vectorassembler:","vectord","vectords:","vectors.dense(1,","vectors:","verbos","veri","version","versions.","via","view","vs","w:","w](other:","want","way","way,","well","well,","well.","when(apttypedds2('city)","when/otherwis","whenev","wherea","why?","window","with,","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withcolumn()","withcolumn(),","withcolumn[citybedsother](lit(list(\"a\",\"b\",\"c\"))).","withcolumntupled()","withdescription(\"sampl","withgroupid(\"samplingjob\").","without","won't","work","work,","worked,","world\")","world|","wrap","wrappedarray((nice,325000.0),","wrappedarray(420000.0)","wrappedarray(6000.0,","wrappedarray(citybeds(paris,2),","wrappedarray(san","wrong","wrongfeatur","wrongfeatures(squarefeet:","wronghousedata","wronghousedata(squarefeet:","wronghousedata?","wronghousefeatures(","wrongrfinput","wrongrfinputs(labelofwrongtype:","wrongtrainingdata","wrongtrainingdata:","wrongtrainingdatawithfeatur","wrongtrainingdatawithfeatures:","w|","w})frameless.typedcolumn[w,out]","x","x:","yet.","zero.","{","|","|+|","|1000|102|","|100|","|133|","|200000.0|","|276333.3333333333|62.833333333333336|","|300000.0|450000.0|","|4500.0|450000.0|","|6000.0|300000.0|","|6908333.333333333|12.566666666666668|hello","|[lyon,45,133000.0,1]|","|[lyon,83,200000.0,2]|","|[nice,74,325000.0,3]|","|[paris,100,450000...|[paris,2229621]|","|[paris,25,250000....|[paris,2229621]|","|[paris,2]|[a,","|[paris,50,300000....|[paris,2229621]|","|city|surface|","|lyon|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|paris|[a,","|paris|[abc,","|value|","}","})","},"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"Introduction","keywords":"","body":"Frameless\n\n\n\n\nFrameless is a Scala library for working with Spark using more expressive types. \nIt consists of the following modules:\n\nframeless-dataset for a more strongly typed Dataset/DataFrame API \nframeless-ml for a more strongly typed Spark ML API based on frameless-dataset\nframeless-cats for using Spark's RDD API with cats\n\nNote that while Frameless is still getting off the ground, it is very possible that breaking changes will be\nmade for at least the next few versions.\nThe Frameless project and contributors support the\nTypelevel Code of Conduct and want all its\nassociated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning.\nVersions and dependencies\nThe compatible versions of Spark and \ncats are as follows: \n\n\n\nFrameless\nSpark\nCats\n\n\n\n\n0.4.0\n2.2.0\n1.0.0-MF\n\n\n0.4.1\n2.2.0\n1.0.1\n\n\n0.5.0\n2.2.1\n1.0.1\n\n\n\nThe only dependency of the frameless-dataset module is on shapeless 2.3.2. \nTherefore, depending on frameless-dataset, has a minimal overhead on your Spark's application jar. \nOnly the frameless-cats module depends on cats, so if you prefer to work just with Datasets and not with RDDs, \nyou may choose not to depend on frameless-cats. \nFrameless intentionally does not have a compile dependency on Spark. \nThis essentially allows you to use any version of Frameless with any version of Spark. \nThe aforementioned table simply provides the versions of Spark we officially compile \nand test Frameless with, but other versions may probably work as well. \nWhy?\nFrameless introduces a new Spark API, called TypedDataset. \nThe benefits of using TypedDataset compared to the standard Spark Dataset API are as follows:\n\nTypesafe columns referencing (e.g., no more runtime errors when accessing non-existing columns)\nCustomizable, typesafe encoders (e.g., if a type does not have an encoder, it should not compile) \nEnhanced type signature for built-in functions (e.g., if you apply an arithmetic operation on a non-numeric column, you \nget a compilation error)\nTypesafe casting and projectios\n\nClick here for a \ndetailed comparison of TypedDataset with Spark's Dataset API. \nDocumentation\n\nTypedDataset: Feature Overview\nTyped Spark ML\nComparing TypedDatasets with Spark's Datasets\nTyped Encoders in Frameless\nInjection: Creating Custom Encoders\nJob[A]\nUsing Cats with RDDs\nProof of Concept: TypedDataFrame\n\nQuick Start\nFrameless is compiled against Scala 2.11.x.\nTo use Frameless in your project add the following in your build.sbt file as needed:\nval framelessVersion = \"0.5.0\"\n\nlibraryDependencies ++= List(\n \"org.typelevel\" %% \"frameless-dataset\" % framelessVersion,\n \"org.typelevel\" %% \"frameless-ml\" % framelessVersion,\n \"org.typelevel\" %% \"frameless-cats\" % framelessVersion \n)\n\nAn easy way to bootstrap a Frameless sbt project:\n\nif you have Giter8 installed then simply:\n\ng8 imarios/frameless.g8\n\n\nwith sbt >= 0.13.13:\n\nsbt new imarios/frameless.g8\n\nTyping sbt console inside your project will bring up a shell with Frameless\nand all its dependencies loaded (including Spark).\nNeed help?\nFeel free to messages us on our gitter \nchannel for any issues/questions.\nDevelopment\nWe require at least one sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers\n(people who can merge pull requests) are:\n\nadelbertc\nimarios\njeremyrsmith\nkanterov\nnon\nOlivierBlanvillain\n\nLicense\nCode is provided under the Apache 2.0 license available at http://opensource.org/licenses/Apache-2.0,\nas well as in the LICENSE file. This is the same license used as Spark.\n"},"FeatureOverview.html":{"url":"FeatureOverview.html","title":"TypedDataset: Feature Overview","keywords":"","body":"TypedDataset: Feature Overview\nThis tutorial introduces TypedDataset using a simple example.\nThe following imports are needed to make all code examples compile.\nimport org.apache.spark.{SparkConf, SparkContext}\nimport org.apache.spark.sql.SparkSession\nimport frameless.functions.aggregate._\nimport frameless.TypedDataset\n\nval conf = new SparkConf().setMaster(\"local[*]\").setAppName(\"Frameless repl\").set(\"spark.ui.enabled\", \"false\")\nimplicit val spark = SparkSession.builder().config(conf).appName(\"REPL\").getOrCreate()\nspark.sparkContext.setLogLevel(\"WARN\")\n\nimport spark.implicits._\n\nCreating TypedDataset instances\nWe start by defining a case class:\ncase class Apartment(city: String, surface: Int, price: Double, bedrooms: Int)\n\nAnd few Apartment instances:\nval apartments = Seq(\n Apartment(\"Paris\", 50, 300000.0, 2),\n Apartment(\"Paris\", 100, 450000.0, 3),\n Apartment(\"Paris\", 25, 250000.0, 1),\n Apartment(\"Lyon\", 83, 200000.0, 2),\n Apartment(\"Lyon\", 45, 133000.0, 1),\n Apartment(\"Nice\", 74, 325000.0, 3)\n)\n\nWe are now ready to instantiate a TypedDataset[Apartment]:\nval aptTypedDs = TypedDataset.create(apartments)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nWe can also create one from an existing Spark Dataset:\nval aptDs = spark.createDataset(apartments)\n// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval aptTypedDs = TypedDataset.create(aptDs)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nOr use the Frameless syntax:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval aptTypedDs2 = aptDs.typed\n// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nTypesafe column referencing\nThis is how we select a particular column from a TypedDataset:\nval cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))\n// cities: frameless.TypedDataset[String] = [_1: string]\n\nThis is completely type-safe, for instance suppose we misspell city as citi:\naptTypedDs.select(aptTypedDs('citi))\n// :27: error: No column Symbol with shapeless.tag.Tagged[String(\"citi\")] of type A in Apartment\n// aptTypedDs.select(aptTypedDs('citi))\n// ^\n\nThis gets raised at compile time, whereas with the standard Dataset API the error appears at runtime (enjoy the stack trace):\naptDs.select('citi)\n// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [city, surface, price, bedrooms];;\n// 'Project ['citi]\n// +- LocalRelation [city#53, surface#54, price#55, bedrooms#56]\n// \n// at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:88)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:85)\n// at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n// at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n// at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:70)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:288)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:279)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:289)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1$1.apply(QueryPlan.scala:293)\n// at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n// at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n// at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)\n// at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)\n// at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n// at scala.collection.AbstractTraversable.map(Traversable.scala:104)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:293)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$6.apply(QueryPlan.scala:298)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:187)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:298)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:268)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:85)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)\n// at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)\n// at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:67)\n// at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2884)\n// at org.apache.spark.sql.Dataset.select(Dataset.scala:1150)\n// ... 430 elided\n\nselect() supports arbitrary column operations:\naptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()\n// +----+---+\n// | _1| _2|\n// +----+---+\n// | 500| 52|\n// |1000|102|\n// | 250| 27|\n// | 830| 85|\n// | 450| 47|\n// | 740| 76|\n// +----+---+\n//\n\nNote that unlike the standard Spark API, where some operations are lazy and some are not, all TypedDatasets operations are lazy.\nIn the above example, show() is lazy. It requires to apply run() for the show job to materialize.\nA more detailed explanation of Job is given here.\nNext we compute the price by surface unit:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// :26: error: overloaded method value / with alternatives:\n// (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] \n// [Out, TT, W](other: frameless.TypedColumn[TT,Double])(implicit n: frameless.CatalystDivisible[Double,Out], implicit e: frameless.TypedEncoder[Out], implicit w: frameless.With[Apartment,TT]{type Out = W})frameless.TypedColumn[W,Out]\n// cannot be applied to (frameless.TypedColumn[Apartment,Int])\n// val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// ^\n\nAs the error suggests, we can't divide a TypedColumn of Double by Int.\nFor safety, in Frameless only math operations between same types is allowed:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [_1: double]\n\npriceBySurfaceUnit.collect().run()\n// res6: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\nLooks like it worked, but that cast seems unsafe right? Actually it is safe.\nLet's try to cast a TypedColumn of String to Double:\naptTypedDs('city).cast[Double]\n// :27: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]\n// aptTypedDs('city).cast[Double]\n// ^\n\nThe compile-time error tells us that to perform the cast, an evidence\n(in the form of CatalystCast[String, Double]) must be available.\nSince casting from String to Double is not allowed, this results\nin a compilation error.\nCheck here\nfor the set of available CatalystCast.\nCasting and projections\nWith select() the resulting TypedDataset is of type TypedDataset[TupleN[...]] (with N in [1...10]).\nFor example, if we select three columns with types String, Int, and Boolean the result will have type\nTypedDataset[(String, Int, Boolean)]. To select more than ten columns use the selectMany() method.\nSelect has better IDE support than the macro based selectMany, so prefer select() for the general case.\nWe often want to give more expressive types to the result of our computations.\nas[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long\nas the types in U and T align.\nWhen the cast is valid the expression compiles:\ncase class UpdatedSurface(city: String, surface: Int)\n// defined class UpdatedSurface\n\nval updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]\n// updated: frameless.TypedDataset[UpdatedSurface] = [city: string, surface: int]\n\nupdated.show(2).run()\n// +-----+-------+\n// | city|surface|\n// +-----+-------+\n// |Paris| 52|\n// |Paris| 102|\n// +-----+-------+\n// only showing top 2 rows\n//\n\nNext we try to cast a (String, String) to an UpdatedSurface (which has types String, Int).\nThe cast is not valid and the expression does not compile:\naptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// :29: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]\n// aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// ^\n\nProjections\nWe often want to work with a subset of the fields in a dataset.\nProjections allows to easily select the fields we are interested\nwhile preserving their initial name and types for extra safety.\nHere is an example using the TypedDataset[Apartment] with an additional column:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\ncase class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)\n// defined class ApartmentDetails\n\nval aptWithRatio =\n aptds.select(\n aptds('city),\n aptds('price),\n aptds('surface),\n aptds('price) / aptds('surface).cast[Double]\n ).as[ApartmentDetails]\n// aptWithRatio: frameless.TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]\n\nSuppose we only want to work with city and ratio:\ncase class CityInfo(city: String, ratio: Double)\n// defined class CityInfo\n\nval cityRatio = aptWithRatio.project[CityInfo]\n// cityRatio: frameless.TypedDataset[CityInfo] = [city: string, ratio: double]\n\ncityRatio.show(2).run()\n// +-----+------+\n// | city| ratio|\n// +-----+------+\n// |Paris|6000.0|\n// |Paris|4500.0|\n// +-----+------+\n// only showing top 2 rows\n//\n\nSuppose we only want to work with price and ratio:\ncase class PriceInfo(ratio: Double, price: Double)\n// defined class PriceInfo\n\nval priceInfo = aptWithRatio.project[PriceInfo]\n// priceInfo: frameless.TypedDataset[PriceInfo] = [ratio: double, price: double]\n\npriceInfo.show(2).run()\n// +------+--------+\n// | ratio| price|\n// +------+--------+\n// |6000.0|300000.0|\n// |4500.0|450000.0|\n// +------+--------+\n// only showing top 2 rows\n//\n\nWe see that the order of the fields does not matter as long as the\nnames and the corresponding types agree. However, if we make a mistake in\nany of the names and/or their types, then we get a compilation error.\nSay we make a typo in a field name:\ncase class PriceInfo2(ratio: Double, pricEE: Double)\n\naptWithRatio.project[PriceInfo2]\n// :29: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?\n// aptWithRatio.project[PriceInfo2]\n// ^\n\nSay we make a mistake in the corresponding type:\ncase class PriceInfo3(ratio: Int, price: Double) // ratio should be Double\n\naptWithRatio.project[PriceInfo3]\n// :29: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?\n// aptWithRatio.project[PriceInfo3]\n// ^\n\nUnion of TypedDatasets\nLets create a projection of our original dataset with a subset of the fields.\ncase class ApartmentShortInfo(city: String, price: Double, bedrooms: Int)\n\nval aptTypedDs2: TypedDataset[ApartmentShortInfo] = aptTypedDs.project[ApartmentShortInfo]\n\nThe union of aptTypedDs2 with aptTypedDs uses all the fields of the caller (aptTypedDs2)\nand expects the other dataset (aptTypedDs) to include all those fields. \nIf field names/types do not match you get a compilation error. \naptTypedDs2.union(aptTypedDs).show().run\n// +-----+--------+--------+\n// | city| price|bedrooms|\n// +-----+--------+--------+\n// |Paris|300000.0| 2|\n// |Paris|450000.0| 3|\n// |Paris|250000.0| 1|\n// | Lyon|200000.0| 2|\n// | Lyon|133000.0| 1|\n// | Nice|325000.0| 3|\n// |Paris|300000.0| 2|\n// |Paris|450000.0| 3|\n// |Paris|250000.0| 1|\n// | Lyon|200000.0| 2|\n// | Lyon|133000.0| 1|\n// | Nice|325000.0| 3|\n// +-----+--------+--------+\n//\n\nThe other way around will not compile, since aptTypedDs2 has only a subset of the fields. \naptTypedDs.union(aptTypedDs2).show().run\n// :28: error: Cannot prove that ApartmentShortInfo can be projected to Apartment. Perhaps not all member names and types of Apartment are the same in ApartmentShortInfo?\n// aptTypedDs.union(aptTypedDs2).show().run\n// ^\n\nFinally, as with project, union will align fields that have same names/types,\nso fields do not have to be in the same order. \nTypedDataset functions and transformations\nFrameless supports many of Spark's functions and transformations. \nHowever, whenever a Spark function does not exist in Frameless, \ncalling .dataset will expose the underlying \nDataset (from org.apache.spark.sql, the original Spark APIs), \nwhere you can use anything that would be missing from the Frameless' API.\nThese are the main imports for Frameless' aggregate and non-aggregate functions.\nimport frameless.functions._ // For literals\nimport frameless.functions.nonAggregate._ // e.g., concat, abs\nimport frameless.functions.aggregate._ // e.g., count, sum, avg\n\nDrop/Replace/Add fields\ndropTupled() drops a single column and results in a tuple-based schema.\naptTypedDs2.dropTupled('price): TypedDataset[(String,Int)]\n// res17: frameless.TypedDataset[(String, Int)] = [_1: string, _2: int]\n\nTo drop a column and specify a new schema use drop().\ncase class CityBeds(city: String, bedrooms: Int)\n// defined class CityBeds\n\nval cityBeds: TypedDataset[CityBeds] = aptTypedDs2.drop[CityBeds] \n// cityBeds: frameless.TypedDataset[CityBeds] = [city: string, bedrooms: int]\n\nOften, you want to replace an existing column with a new value.\nval inflation = aptTypedDs2.withColumnReplaced('price, aptTypedDs2('price) * 2)\n// inflation: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]\n\ninflation.show(2).run()\n// +-----+--------+--------+\n// | city| price|bedrooms|\n// +-----+--------+--------+\n// |Paris|600000.0| 2|\n// |Paris|900000.0| 3|\n// +-----+--------+--------+\n// only showing top 2 rows\n//\n\nOr use a literal instead.\nimport frameless.functions.lit\n// import frameless.functions.lit\n\naptTypedDs2.withColumnReplaced('price, lit(0.001)) \n// res19: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]\n\nAdding a column using withColumnTupled() results in a tupled-based schema.\naptTypedDs2.withColumnTupled(lit(Array(\"a\",\"b\",\"c\"))).show(2).run()\n// +-----+--------+---+---------+\n// | _1| _2| _3| _4|\n// +-----+--------+---+---------+\n// |Paris|300000.0| 2|[a, b, c]|\n// |Paris|450000.0| 3|[a, b, c]|\n// +-----+--------+---+---------+\n// only showing top 2 rows\n//\n\nSimilarly, withColumn() adds a column and explicitly expects a schema for the result.\ncase class CityBedsOther(city: String, bedrooms: Int, other: List[String])\n// defined class CityBedsOther\n\ncityBeds.\n withColumn[CityBedsOther](lit(List(\"a\",\"b\",\"c\"))).\n show(1).run()\n// +-----+--------+---------+\n// | city|bedrooms| other|\n// +-----+--------+---------+\n// |Paris| 2|[a, b, c]|\n// +-----+--------+---------+\n// only showing top 1 row\n//\n\nTo conditionally change a column use the when/otherwise operation. \nimport frameless.functions.nonAggregate.when\n// import frameless.functions.nonAggregate.when\n\naptTypedDs2.withColumnTupled(\n when(aptTypedDs2('city) === \"Paris\", aptTypedDs2('price)).\n when(aptTypedDs2('city) === \"Lyon\", lit(1.1)).\n otherwise(lit(0.0))).show(8).run()\n// +-----+--------+---+--------+\n// | _1| _2| _3| _4|\n// +-----+--------+---+--------+\n// |Paris|300000.0| 2|300000.0|\n// |Paris|450000.0| 3|450000.0|\n// |Paris|250000.0| 1|250000.0|\n// | Lyon|200000.0| 2| 1.1|\n// | Lyon|133000.0| 1| 1.1|\n// | Nice|325000.0| 3| 0.0|\n// +-----+--------+---+--------+\n//\n\nA simple way to add a column without loosing important schema information is\nto project the entire source schema into a single column using the asCol() method.\nval c = cityBeds.select(cityBeds.asCol, lit(List(\"a\",\"b\",\"c\")))\n// c: frameless.TypedDataset[(CityBeds, List[String])] = [_1: struct, _2: array]\n\nc.show(1).run()\n// +---------+---------+\n// | _1| _2|\n// +---------+---------+\n// |[Paris,2]|[a, b, c]|\n// +---------+---------+\n// only showing top 1 row\n//\n\nasCol() is a new method, without a direct equivalent in Spark's Dataset or DataFrame APIs.\nWhen working with Spark's DataFrames, you often select all columns using .select($\"*\", ...). \nIn a way, asCol() is a typed equivalent of $\"*\". \nFinally, note that using select() and asCol(), compared to using withColumn(), avoids the \nneed of an extra case class to define the result schema.\nTo access nested columns, use the colMany() method. \nc.select(c.colMany('_1, 'city), c('_2)).show(2).run()\n// +-----+---------+\n// | _1| _2|\n// +-----+---------+\n// |Paris|[a, b, c]|\n// |Paris|[a, b, c]|\n// +-----+---------+\n// only showing top 2 rows\n//\n\nWorking with collections\nimport frameless.functions._\n// import frameless.functions._\n\nimport frameless.functions.nonAggregate._\n// import frameless.functions.nonAggregate._\n\nval t = cityRatio.select(cityRatio('city), lit(List(\"abc\",\"c\",\"d\")))\n// t: frameless.TypedDataset[(String, List[String])] = [_1: string, _2: array]\n\nt.withColumnTupled(\n arrayContains(t('_2), \"abc\")\n).show(1).run()\n// +-----+-----------+----+\n// | _1| _2| _3|\n// +-----+-----------+----+\n// |Paris|[abc, c, d]|true|\n// +-----+-----------+----+\n// only showing top 1 row\n//\n\nIf accidentally you apply a collection function on a column that is not a collection,\nyou get a compilation error.\nt.withColumnTupled(\n arrayContains(t('_1), \"abc\")\n)\n// :36: error: no type parameters for method arrayContains: (column: frameless.AbstractTypedColumn[T,C[A]], value: A)(implicit evidence$1: frameless.CatalystCollection[C])column.ThisType[T,Boolean] exist so that it can be applied to arguments (frameless.TypedColumn[(String, List[String]),String], String)\n// --- because ---\n// argument expression's type is not compatible with formal parameter type;\n// found : frameless.TypedColumn[(String, List[String]),String]\n// required: frameless.AbstractTypedColumn[?T,?C[?A]]\n// \n// arrayContains(t('_1), \"abc\")\n// ^\n// :36: error: type mismatch;\n// found : frameless.TypedColumn[(String, List[String]),String]\n// required: frameless.AbstractTypedColumn[T,C[A]]\n// arrayContains(t('_1), \"abc\")\n// ^\n// :36: error: type mismatch;\n// found : String(\"abc\")\n// required: A\n// arrayContains(t('_1), \"abc\")\n// ^\n// :36: error: Cannot do collection operations on columns of type C.\n// arrayContains(t('_1), \"abc\")\n// ^\n\nCollecting data to the driver\nIn Frameless all Spark actions (such as collect()) are safe.\nTake the first element from a dataset (if the dataset is empty return None).\ncityBeds.headOption.run()\n// res27: Option[CityBeds] = Some(CityBeds(Paris,2))\n\nTake the first n elements.\ncityBeds.take(2).run()\n// res28: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3))\n\ncityBeds.head(3).run()\n// res29: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1))\n\ncityBeds.limit(4).collect().run()\n// res30: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1), CityBeds(Lyon,2))\n\nSorting columns\nOnly column types that can be sorted are allowed to be selected for sorting. \naptTypedDs.orderBy(aptTypedDs('city).asc).show(2).run()\n// +----+-------+--------+--------+\n// |city|surface| price|bedrooms|\n// +----+-------+--------+--------+\n// |Lyon| 83|200000.0| 2|\n// |Lyon| 45|133000.0| 1|\n// +----+-------+--------+--------+\n// only showing top 2 rows\n//\n\nThe ordering can be changed by selecting .acs or .desc. \naptTypedDs.orderBy(\n aptTypedDs('city).asc, \n aptTypedDs('price).desc\n).show(2).run()\n// +----+-------+--------+--------+\n// |city|surface| price|bedrooms|\n// +----+-------+--------+--------+\n// |Lyon| 83|200000.0| 2|\n// |Lyon| 45|133000.0| 1|\n// +----+-------+--------+--------+\n// only showing top 2 rows\n//\n\nUser Defined Functions\nFrameless supports lifting any Scala function (up to five arguments) to the\ncontext of a particular TypedDataset:\n// The function we want to use as UDF\nval priceModifier =\n (name: String, price:Double) => if(name == \"Paris\") price * 2.0 else price\n// priceModifier: (String, Double) => Double = \n\nval udf = aptTypedDs.makeUDF(priceModifier)\n// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = \n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))\n// adjustedPrice: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\nadjustedPrice.show().run()\n// +-----+--------+\n// | _1| _2|\n// +-----+--------+\n// |Paris|600000.0|\n// |Paris|900000.0|\n// |Paris|500000.0|\n// | Lyon|200000.0|\n// | Lyon|133000.0|\n// | Nice|325000.0|\n// +-----+--------+\n//\n\nGroupBy and Aggregations\nLet's suppose we wanted to retrieve the average apartment price in each city\nval priceByCity = aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('price)))\n// priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\npriceByCity.collect().run()\n// res35: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))\n\nAgain if we try to aggregate a column that can't be aggregated, we get a compilation error\naptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))\n// :35: error: Cannot compute average of type String.\n// aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))\n// ^\n\nNext, we combine select and groupBy to calculate the average price/surface ratio per city:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval cityPriceRatio = aptds.select(aptds('city), aptds('price) / aptds('surface).cast[Double])\n// cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\ncityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()\n// +-----+------------------+\n// | _1| _2|\n// +-----+------------------+\n// | Nice| 4391.891891891892|\n// |Paris| 6833.333333333333|\n// | Lyon|2682.5970548862115|\n// +-----+------------------+\n//\n\nWe can also use pivot to further group data on a secondary column.\nFor example, we can compare the average price across cities by number of bedrooms.\ncase class BedroomStats(\n city: String,\n AvgPriceBeds1: Option[Double], // Pivot values may be missing, so we encode them using Options\n AvgPriceBeds2: Option[Double],\n AvgPriceBeds3: Option[Double],\n AvgPriceBeds4: Option[Double])\n// defined class BedroomStats\n\nval bedroomStats = aptds.\n groupBy(aptds('city)).\n pivot(aptds('bedrooms)).\n on(1,2,3,4). // We only care for up to 4 bedrooms\n agg(avg(aptds('price))).\n as[BedroomStats] // Typesafe casting\n// bedroomStats: frameless.TypedDataset[BedroomStats] = [city: string, AvgPriceBeds1: double ... 3 more fields]\n\nbedroomStats.show().run()\n// +-----+-------------+-------------+-------------+-------------+\n// | city|AvgPriceBeds1|AvgPriceBeds2|AvgPriceBeds3|AvgPriceBeds4|\n// +-----+-------------+-------------+-------------+-------------+\n// | Nice| null| null| 325000.0| null|\n// |Paris| 250000.0| 300000.0| 450000.0| null|\n// | Lyon| 133000.0| 200000.0| null| null|\n// +-----+-------------+-------------+-------------+-------------+\n//\n\nWith pivot, collecting data preserves typesafety by\nencoding potentially missing columns with Option.\nbedroomStats.collect().run().foreach(println)\n// BedroomStats(Nice,None,None,Some(325000.0),None)\n// BedroomStats(Paris,Some(250000.0),Some(300000.0),Some(450000.0),None)\n// BedroomStats(Lyon,Some(133000.0),Some(200000.0),None,None)\n\nWorking with Optional fields\nOptional fields can be converted to non-optional using getOrElse(). \nval sampleStats = bedroomStats.select(\n bedroomStats('AvgPriceBeds2).getOrElse(0.0),\n bedroomStats('AvgPriceBeds3).getOrElse(0.0))\n// sampleStats: frameless.TypedDataset[(Double, Double)] = [_1: double, _2: double]\n\nsampleStats.show().run() \n// +--------+--------+\n// | _1| _2|\n// +--------+--------+\n// | 0.0|325000.0|\n// |300000.0|450000.0|\n// |200000.0| 0.0|\n// +--------+--------+\n//\n\nEntire TypedDataset Aggregation\nWe often want to aggregate the entire TypedDataset and skip the groupBy() clause.\nIn Frameless you can do this using the agg() operator directly on the TypedDataset.\nIn the following example, we compute the average price, the average surface,\nthe minimum surface, and the set of cities for the entire dataset.\ncase class Stats(\n avgPrice: Double,\n avgSurface: Double,\n minSurface: Int,\n allCities: Vector[String])\n// defined class Stats\n\naptds.agg(\n avg(aptds('price)),\n avg(aptds('surface)),\n min(aptds('surface)),\n collectSet(aptds('city))\n).as[Stats].show().run()\n// +-----------------+------------------+----------+-------------------+\n// | avgPrice| avgSurface|minSurface| allCities|\n// +-----------------+------------------+----------+-------------------+\n// |276333.3333333333|62.833333333333336| 25|[Paris, Nice, Lyon]|\n// +-----------------+------------------+----------+-------------------+\n//\n\nYou may apply any TypedColumn operation to a TypedAggregate column as well.\nimport frameless.functions._\n// import frameless.functions._\n\naptds.agg(\n avg(aptds('price)) * min(aptds('surface)).cast[Double], \n avg(aptds('surface)) * 0.2,\n litAggr(\"Hello World\")\n).show().run()\n// +-----------------+------------------+-----------+\n// | _1| _2| _3|\n// +-----------------+------------------+-----------+\n// |6908333.333333333|12.566666666666668|Hello World|\n// +-----------------+------------------+-----------+\n//\n\nJoins\ncase class CityPopulationInfo(name: String, population: Int)\n\nval cityInfo = Seq(\n CityPopulationInfo(\"Paris\", 2229621),\n CityPopulationInfo(\"Lyon\", 500715),\n CityPopulationInfo(\"Nice\", 343629)\n)\n\nval citiInfoTypedDS = TypedDataset.create(cityInfo)\n\nHere is how to join the population information to the apartment's dataset:\nval withCityInfo = aptTypedDs.joinInner(citiInfoTypedDS) { aptTypedDs('city) === citiInfoTypedDS('name) }\n// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct, _2: struct]\n\nwithCityInfo.show().run()\n// +--------------------+---------------+\n// | _1| _2|\n// +--------------------+---------------+\n// |[Paris,50,300000....|[Paris,2229621]|\n// |[Paris,100,450000...|[Paris,2229621]|\n// |[Paris,25,250000....|[Paris,2229621]|\n// |[Lyon,83,200000.0,2]| [Lyon,500715]|\n// |[Lyon,45,133000.0,1]| [Lyon,500715]|\n// |[Nice,74,325000.0,3]| [Nice,343629]|\n// +--------------------+---------------+\n//\n\nThe joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].\nWe can then select which information we want to continue to work with:\ncase class AptPriceCity(city: String, aptPrice: Double, cityPopulation: Int)\n// defined class AptPriceCity\n\nwithCityInfo.select(\n withCityInfo.colMany('_2, 'name), withCityInfo.colMany('_1, 'price), withCityInfo.colMany('_2, 'population)\n).as[AptPriceCity].show().run\n// +-----+--------+--------------+\n// | city|aptPrice|cityPopulation|\n// +-----+--------+--------------+\n// |Paris|300000.0| 2229621|\n// |Paris|450000.0| 2229621|\n// |Paris|250000.0| 2229621|\n// | Lyon|200000.0| 500715|\n// | Lyon|133000.0| 500715|\n// | Nice|325000.0| 343629|\n// +-----+--------+--------------+\n//\n\n"},"TypedDatasetVsSparkDataset.html":{"url":"TypedDatasetVsSparkDataset.html","title":"Comparing TypedDatasets with Spark's Datasets","keywords":"","body":"Comparing TypedDatasets with Spark's Datasets\nGoal:\n This tutorial compares the standard Spark Datasets API with the one provided by\n Frameless' TypedDataset. It shows how TypedDatasets allow for an expressive and\n type-safe api with no compromises on performance.\nFor this tutorial we first create a simple dataset and save it on disk as a parquet file.\nParquet is a popular columnar format and well supported by Spark.\nIt's important to note that when operating on parquet datasets, Spark knows that each column is stored\nseparately, so if we only need a subset of the columns Spark will optimize for this and avoid reading\nthe entire dataset. This is a rather simplistic view of how Spark and parquet work together but it\nwill serve us well for the context of this discussion.\nimport spark.implicits._\n// import spark.implicits._\n\n// Our example case class Foo acting here as a schema\ncase class Foo(i: Long, j: String)\n// defined class Foo\n\n// Assuming spark is loaded and SparkSession is bind to spark\nval initialDs = spark.createDataset( Foo(1, \"Q\") :: Foo(10, \"W\") :: Foo(100, \"E\") :: Nil )\n// initialDs: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\n// Assuming you are on Linux or Mac OS\ninitialDs.write.parquet(\"/tmp/foo\")\n\nval ds = spark.read.parquet(\"/tmp/foo\").as[Foo]\n// ds: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\nds.show()\n// +---+---+\n// | i| j|\n// +---+---+\n// | 1| Q|\n// | 10| W|\n// |100| E|\n// +---+---+\n//\n\nThe value ds holds the content of the initialDs read from a parquet file.\nLet's try to only use field i from Foo and see how Spark's Catalyst (the query optimizer)\noptimizes this.\n// Using a standard Spark TypedColumn in select()\nval filteredDs = ds.filter($\"i\" === 10).select($\"i\".as[Long])\n// filteredDs: org.apache.spark.sql.Dataset[Long] = [i: bigint]\n\nfilteredDs.show()\n// +---+\n// | i|\n// +---+\n// | 10|\n// +---+\n//\n\nThe filteredDs is of type Dataset[Long]. Since we only access field i from Foo the type is correct.\nUnfortunately, this syntax requires handholding by explicitly setting the TypedColumn in the select statement\nto return type Long (look at the as[Long] statement). We will discuss this limitation next in more detail.\nNow, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.\nfilteredDs.explain()\n// == Physical Plan ==\n// *Project [i#1771L]\n// +- *Filter (isnotnull(i#1771L) && (i#1771L = 10))\n// +- *FileScan parquet [i#1771L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nThe last line is very important (see ReadSchema). The schema read\nfrom the parquet file only required reading column i without needing to access column j.\nThis is great! We have both an optimized query plan and type-safety!\nUnfortunately, this syntax is not bulletproof: it fails at run-time if we try to access\na non existing column x:\nscala> ds.filter($\"i\" === 10).select($\"x\".as[Long])\norg.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];;\n'Project ['x]\n+- Filter (i#1771L = cast(10 as bigint))\n +- Relation[i#1771L,j#1772] parquet\n\n at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:88)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$2.applyOrElse(CheckAnalysis.scala:85)\n at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n at org.apache.spark.sql.catalyst.trees.TreeNode$$anonfun$transformUp$1.apply(TreeNode.scala:289)\n at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:70)\n at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:288)\n at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$transformExpressionsUp$1.apply(QueryPlan.scala:268)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:279)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:289)\n at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1$1.apply(QueryPlan.scala:293)\n at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n at scala.collection.TraversableLike$$anonfun$map$1.apply(TraversableLike.scala:234)\n at scala.collection.immutable.List.foreach(List.scala:392)\n at scala.collection.TraversableLike$class.map(TraversableLike.scala:234)\n at scala.collection.immutable.List.map(List.scala:296)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.org$apache$spark$sql$catalyst$plans$QueryPlan$$recursiveTransform$1(QueryPlan.scala:293)\n at org.apache.spark.sql.catalyst.plans.QueryPlan$$anonfun$6.apply(QueryPlan.scala:298)\n at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:187)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:298)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:268)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:85)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)\n at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)\n at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)\n at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)\n at org.apache.spark.sql.Dataset.(Dataset.scala:165)\n at org.apache.spark.sql.Dataset.(Dataset.scala:171)\n at org.apache.spark.sql.Dataset.select(Dataset.scala:1210)\n ... 454 elided\n\nThere are two things to improve here. First, we would want to avoid the as[Long] casting that we are required\nto type for type-safety. This is clearly an area where we may introduce a bug by casting to an incompatible\ntype. Second, we want a solution where reference to a non existing column name fails at compilation time.\nThe standard Spark Dataset can achieve this using the following syntax.\nds.filter(_.i == 10).map(_.i).show()\n// +-----+\n// |value|\n// +-----+\n// | 10|\n// +-----+\n//\n\nThis looks great! It reminds us the familiar syntax from Scala.\nThe two closures in filter and map are functions that operate on Foo and the\ncompiler will helps us capture all the mistakes we mentioned above.\nscala> ds.filter(_.i == 10).map(_.x).show()\n:20: error: value x is not a member of Foo\n ds.filter(_.i == 10).map(_.x).show()\n ^\n\nUnfortunately, this syntax does not allow Spark to optimize the code.\nds.filter(_.i == 10).map(_.i).explain()\n// == Physical Plan ==\n// *SerializeFromObject [input[0, bigint, false] AS value#1805L]\n// +- *MapElements , obj#1804: bigint\n// +- *Filter .apply\n// +- *DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#1803: $line14.$read$$iw$$iw$$iw$$iw$Foo\n// +- *FileScan parquet [i#1771L,j#1772] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [], ReadSchema: struct\n\nAs we see from the explained Physical Plan, Spark was not able to optimize our query as before.\nReading the parquet file will required loading all the fields of Foo. This might be ok for\nsmall datasets or for datasets with few columns, but will be extremely slow for most practical\napplications. Intuitively, Spark currently does not have a way to look inside the code we pass in these two\nclosures. It only knows that they both take one argument of type Foo, but it has no way of knowing if\nwe use just one or all of Foo's fields.\nThe TypedDataset in Frameless solves this problem. It allows for a simple and type-safe syntax\nwith a fully optimized query plan.\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport frameless.syntax._\n// import frameless.syntax._\n\nval fds = TypedDataset.create(ds)\n// fds: frameless.TypedDataset[Foo] = [i: bigint, j: string]\n\nfds.filter(fds('i) === 10).select(fds('i)).show().run()\n// +---+\n// | _1|\n// +---+\n// | 10|\n// +---+\n//\n\nAnd the optimized Physical Plan:\nfds.filter(fds('i) === 10).select(fds('i)).explain()\n// == Physical Plan ==\n// *Project [i#1771L AS _1#1876L]\n// +- *Filter (isnotnull(i#1771L) && (i#1771L = 10))\n// +- *FileScan parquet [i#1771L] Batched: true, Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n\nAnd the compiler is our friend.\nscala> fds.filter(fds('i) === 10).select(fds('x))\n:24: error: No column Symbol with shapeless.tag.Tagged[String(\"x\")] of type A in Foo\n fds.filter(fds('i) === 10).select(fds('x))\n ^\n\nDifferences in Encoders\nEncoders in Spark's Datasets are partially type-safe. If you try to create a Dataset using a type that is not \n a Scala Product then you get a compilation error:\nclass Bar(i: Int)\n// defined class Bar\n\nBar is neither a case class nor a Product, so the following correctly gives a compilation error in Spark:\nscala> spark.createDataset(Seq(new Bar(1)))\n:24: error: Unable to find encoder for type stored in a Dataset. Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._ Support for serializing other types will be added in future releases.\n spark.createDataset(Seq(new Bar(1)))\n ^\n\nHowever, the compile type guards implemented in Spark are not sufficient to detect non encodable members. \nFor example, using the following case class leads to a runtime failure:\ncase class MyDate(jday: java.util.Date)\n// defined class MyDate\n\nval myDateDs = spark.createDataset(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// java.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n// - field (class: \"java.util.Date\", name: \"jday\")\n// - root class: \"MyDate\"\n// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:632)\n// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:455)\n// at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:56)\n// at org.apache.spark.sql.catalyst.ScalaReflection$class.cleanUpReflectionObjects(ScalaReflection.scala:809)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:39)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:455)\n// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1$$anonfun$10.apply(ScalaReflection.scala:626)\n// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1$$anonfun$10.apply(ScalaReflection.scala:614)\n// at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n// at scala.collection.TraversableLike$$anonfun$flatMap$1.apply(TraversableLike.scala:241)\n// at scala.collection.immutable.List.foreach(List.scala:392)\n// at scala.collection.TraversableLike$class.flatMap(TraversableLike.scala:241)\n// at scala.collection.immutable.List.flatMap(List.scala:355)\n// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:614)\n// at org.apache.spark.sql.catalyst.ScalaReflection$$anonfun$org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor$1.apply(ScalaReflection.scala:455)\n// at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:56)\n// at org.apache.spark.sql.catalyst.ScalaReflection$class.cleanUpReflectionObjects(ScalaReflection.scala:809)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:39)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.org$apache$spark$sql$catalyst$ScalaReflection$$serializerFor(ScalaReflection.scala:455)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:444)\n// at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:71)\n// at org.apache.spark.sql.Encoders$.product(Encoders.scala:275)\n// at org.apache.spark.sql.LowPrioritySQLImplicits$class.newProductEncoder(SQLImplicits.scala:233)\n// at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:33)\n// ... 770 elided\n\nIn comparison, a TypedDataset will notify about the encoding problem at compile time: \nTypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// :25: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[MyDate]\n// TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// ^\n\nAggregate vs Projected columns\nSpark's Dataset do not distinguish between columns created from aggregate operations, \nsuch as summing or averaging, and simple projections/selections. \nThis is problematic when you start mixing the two.\nimport org.apache.spark.sql.functions.sum\n// import org.apache.spark.sql.functions.sum\n\nds.select(sum($\"i\"), $\"i\"*2)\n// org.apache.spark.sql.AnalysisException: grouping expressions sequence is empty, and '`i`' is not an aggregate function. Wrap '(sum(`i`) AS `sum(i)`)' in windowing function(s) or wrap '`i`' in first() (or first_value) if you don't care which value you get.;;\n// Aggregate [sum(i#1771L) AS sum(i)#1889L, (i#1771L * cast(2 as bigint)) AS (i * 2)#1890L]\n// +- Relation[i#1771L,j#1772] parquet\n// \n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.failAnalysis(CheckAnalysis.scala:39)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.failAnalysis(Analyzer.scala:91)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1(CheckAnalysis.scala:239)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)\n// at scala.collection.immutable.List.foreach(List.scala:392)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1(CheckAnalysis.scala:253)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1$5.apply(CheckAnalysis.scala:253)\n// at scala.collection.immutable.List.foreach(List.scala:392)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.org$apache$spark$sql$catalyst$analysis$CheckAnalysis$class$$anonfun$$checkValidAggregateExpression$1(CheckAnalysis.scala:253)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$9.apply(CheckAnalysis.scala:280)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1$$anonfun$apply$9.apply(CheckAnalysis.scala:280)\n// at scala.collection.mutable.ResizableArray$class.foreach(ResizableArray.scala:59)\n// at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:48)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:280)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$checkAnalysis$1.apply(CheckAnalysis.scala:78)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:127)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$class.checkAnalysis(CheckAnalysis.scala:78)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:91)\n// at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:52)\n// at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:67)\n// at org.apache.spark.sql.Dataset.org$apache$spark$sql$Dataset$$withPlan(Dataset.scala:2884)\n// at org.apache.spark.sql.Dataset.select(Dataset.scala:1150)\n// ... 854 elided\n\nIn Frameless, mixing the two results in a compilation error.\n// To avoid confusing frameless' sum with the standard Spark's sum\nimport frameless.functions.aggregate.{sum => fsum}\n// import frameless.functions.aggregate.{sum=>fsum}\n\nfds.select(fsum(fds('i)))\n// :26: error: polymorphic expression cannot be instantiated to expected type;\n// found : [Out]frameless.TypedAggregate[Foo,Out]\n// required: frameless.TypedColumn[Foo,?]\n// fds.select(fsum(fds('i)))\n// ^\n\nAs the error suggests, we expected a TypedColumn but we got a TypedAggregate instead. \nHere is how you apply an aggregation method in Frameless: \nfds.agg(fsum(fds('i))+22).show().run()\n// +---+\n// | _1|\n// +---+\n// |133|\n// +---+\n//\n\nSimilarly, mixing projections while aggregating does not make sense, and in Frameless\nyou get a compilation error. \nfds.agg(fsum(fds('i)), fds('i)).show().run()\n// :26: error: polymorphic expression cannot be instantiated to expected type;\n// found : [A]frameless.TypedColumn[Foo,A]\n// required: frameless.TypedAggregate[Foo,?]\n// fds.agg(fsum(fds('i)), fds('i)).show().run()\n// ^\n\n"},"TypedEncoder.html":{"url":"TypedEncoder.html","title":"Typed Encoders in Frameless","keywords":"","body":"Typed Encoders in Frameless\nSpark uses Reflection to derive its Encoders, which is why they can fail at run time. For example, because Spark does not support java.util.Date, the following leads to an error:\nimport org.apache.spark.sql.Dataset\nimport spark.implicits._\n\ncase class DateRange(s: java.util.Date, e: java.util.Date)\n\nscala> val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))\n:24: error: not found: value sqlContext\n val ds: Dataset[DateRange] = sqlContext.createDataset(Seq(DateRange(new java.util.Date, new java.util.Date)))\n ^\n\nAs shown by the stack trace, this runtime error goes through ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection-based approach is its inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.\nFrameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every Frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless' type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the java.util.Date example won't compile with Frameless:\nimport frameless.TypedDataset\nimport frameless.syntax._\n\nval ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// :28: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]\n// val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// ^\n\nType class derivation takes care of recursively constructing (and proving the existence of) TypeEncoders for case classes. The following works as expected:\ncase class Bar(d: Double, s: String)\n// defined class Bar\n\ncase class Foo(i: Int, b: Bar)\n// defined class Foo\n\nval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, \"s\"))))\n// ds: frameless.TypedDataset[Foo] = [i: int, b: struct]\n\nds.collect()\n// res2: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@558c6c17\n\nBut any non-encodable in the case class hierarchy will be detected at compile time:\ncase class BarDate(d: Double, s: String, t: java.util.Date)\ncase class FooDate(i: Int, b: BarDate)\n\nval ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// :30: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]\n// val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// ^\n\nIt should be noted that once derived, reflection-based Encoders and implicitly derived TypeEncoders have identical performance. The derivation mechanism is different, but the objects generated to encode and decode JVM objects in Spark's internal representation behave the same at runtime.\n"},"Injection.html":{"url":"Injection.html","title":"Injection: Creating Custom Encoders","keywords":"","body":"Injection: Creating Custom Encoders\nInjection lets us define encoders for types that do not have one by injecting A into an encodable type B.\nThis is the definition of the injection typeclass:\ntrait Injection[A, B] extends Serializable {\n def apply(a: A): B\n def invert(b: B): A\n}\n\nExample\nLet's define a simple case class:\ncase class Person(age: Int, birthday: java.util.Date)\n// defined class Person\n\nval people = Seq(Person(42, new java.util.Date))\n// people: Seq[Person] = List(Person(42,Sun Feb 18 15:18:58 PST 2018))\n\nAnd an instance of a TypedDataset:\nval personDS = TypedDataset.create(people)\n// :23: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n// val personDS = TypedDataset.create(people)\n// ^\n\nLooks like we can't, a TypedEncoder instance of Person is not available, or more precisely for java.util.Date.\nBut we can define a injection from java.util.Date to an encodable type, like Long:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = new Injection[java.util.Date, Long] {\n def apply(d: java.util.Date): Long = d.getTime()\n def invert(l: Long): java.util.Date = new java.util.Date(l)\n}\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@37f23430\n\nWe can be less verbose using the Injection.apply function:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@6cd20faa\n\nNow we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, birthday: bigint]\n\nAnother example\nLet's define a sealed family:\nsealed trait Gender\n// defined trait Gender\n\ncase object Male extends Gender\n// defined object Male\n\ncase object Female extends Gender\n// defined object Female\n\ncase object Other extends Gender\n// defined object Other\n\nAnd a simple case class:\ncase class Person(age: Int, gender: Gender)\n// defined class Person\n\nval people = Seq(Person(42, Male))\n// people: Seq[Person] = List(Person(42,Male))\n\nAgain if we try to create a TypedDataset, we get a compilation error.\nval personDS = TypedDataset.create(people)\n// :31: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n// val personDS = TypedDataset.create(people)\n// ^\n\nLet's define an injection instance for Gender:\nimplicit val genderToInt: Injection[Gender, Int] = Injection(\n {\n case Male => 1\n case Female => 2\n case Other => 3\n },\n {\n case 1 => Male\n case 2 => Female\n case 3 => Other\n })\n// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@4d1cf7ad\n\nAnd now we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, gender: int]\n\n"},"Job.html":{"url":"Job.html","title":"Job[A]","keywords":"","body":"Job[A]\nAll operations on TypedDataset are lazy. An operation either returns a new\ntransformed TypedDataset or an F[A], where F[_] is a type constructor\nwith an instance of the SparkDelay typeclass and A is the result of running a\nnon-lazy computation in Spark. \nA default such type constructor called Job is provided by Frameless. \nJob serves several functions:\n\nMakes all operations on a TypedDataset lazy, which makes them more predictable compared to having\nfew operations being lazy and other being strict\nAllows the programmer to make expensive blocking operations explicit\nAllows for Spark jobs to be lazily sequenced using monadic composition via for-comprehension\nProvides an obvious place where you can annotate/name your Spark jobs to make it easier\nto track different parts of your application in the Spark UI\n\nThe toy example showcases the use of for-comprehension to explicitly sequences Spark Jobs.\nFirst we calculate the size of the TypedDataset and then we collect to the driver\nexactly 20% of its elements:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval ds = TypedDataset.create(1 to 20)\n// ds: frameless.TypedDataset[Int] = [_1: int]\n\nval countAndTakeJob =\n for {\n count \nThe countAndTakeJob can either be executed using run() (as we show above) or it can\nbe passed along to other parts of the program to be further composed into more complex sequences\nof Spark jobs.\nimport frameless.Job\n// import frameless.Job\n\ndef computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min)\n// computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]\n\nval finalJob = computeMinOfSample(countAndTakeJob)\n// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@30c69a34\n\nNow we can execute this new job by specifying a group-id and a description.\nThis allows the programmer to see this information on the Spark UI and help track, say,\nperformance issues.\nfinalJob.\n withGroupId(\"samplingJob\").\n withDescription(\"Samples 20% of elements and computes the min\").\n run()\n// res2: Int = 1\n\nMore on SparkDelay\nAs mentioned above, SparkDelay[F[_]] is a typeclass required for suspending\neffects by Spark computations. This typeclass represents the ability to suspend\nan => A thunk into an F[A] value, while implicitly capturing a SparkSession.\nAs it is a typeclass, it is open for implementation by the user in order to use\nother data types for suspension of effects. The cats module, for example, uses\nthis typeclass to support suspending Spark computations in any effect type that\nhas a cats.effect.Sync instance.\n"},"Cats.html":{"url":"Cats.html","title":"Using Cats with RDDs","keywords":"","body":"Using Cats with Frameless\nThere are two main parts to the cats integration offered by Frameless:\n\neffect suspension in TypedDataset using cats-effect and cats-mtl\nRDD enhancements using algebraic typeclasses in cats-kernel\n\nAll the examples below assume you have previously imported cats.implicits and frameless.cats.implicits.\nNote that you should not import frameless.syntax._ together with frameless.cats.implicits._.\nimport cats.implicits._\n// import cats.implicits._\n\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nEffect Suspension in typed datasets\nAs noted in the section about Job, all operations on TypedDataset are lazy. The results of \noperations that would normally block on plain Spark APIs are wrapped in a type constructor F[_], \nfor which there exists an instance of SparkDelay[F]. This typeclass represents the operation of \ndelaying a computation and capturing an implicit SparkSession. \nIn the cats module, we utilize the typeclasses from cats-effect for abstracting over these \neffect types - namely, we provide an implicit SparkDelay instance for all F[_] for which exists\nan instance of cats.effect.Sync[F].\nThis allows one to run operations on TypedDataset in an existing monad stack. For example, given\nthis pre-existing monad stack:\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport cats.data.ReaderT\n// import cats.data.ReaderT\n\nimport cats.effect.IO\n// import cats.effect.IO\n\nimport cats.effect.implicits._\n// import cats.effect.implicits._\n\ntype Action[T] = ReaderT[IO, SparkSession, T]\n// defined type alias Action\n\nWe will be able to request that values from TypedDataset will be suspended in this stack:\nval typedDs = TypedDataset.create(Seq((1, \"string\"), (2, \"another\")))\n// typedDs: frameless.TypedDataset[(Int, String)] = [_1: int, _2: string]\n\nval result: Action[(Seq[(Int, String)], Long)] = for {\n sample )\n\nAs with Job, note that nothing has been run yet. The effect has been properly suspended. To\nrun our program, we must first supply the SparkSession to the ReaderT layer and then\nrun the IO effect:\nresult.run(spark).unsafeRunSync()\n// res5: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)\n\nConvenience methods for modifying Spark thread-local variables\nThe frameless.cats.implicits._ import also provides some syntax enrichments for any monad\nstack that has the same capabilities as Action above. Namely, the ability to provide an\ninstance of SparkSession and the ability to suspend effects.\nFor these to work, we will need to import the implicit machinery from the cats-mtl library:\nimport cats.mtl.implicits._\n// import cats.mtl.implicits._\n\nAnd now, we can set the description for the computation being run:\nval resultWithDescription: Action[(Seq[(Int, String)], Long)] = for {\n r )\n\nresultWithDescription.run(spark).unsafeRunSync()\n// Description: fancy cats\n// res6: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)\n\nUsing algebraic typeclasses from Cats with RDDs\nData aggregation is one of the most important operations when working with Spark (and data in general).\nFor example, we often have to compute the min, max, avg, etc. from a set of columns grouped by\ndifferent predicates. This section shows how cats simplifies these tasks in Spark by\nleveraging a large collection of Type Classes for ordering and aggregating data.\nCats offers ways to sort and aggregate tuples of arbitrary arity.\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nval data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[14] at makeRDD at :44\n\nprintln(data.csum)\n// (10,9,9)\n\nprintln(data.cmax)\n// (8,2,3)\n\nprintln(data.cmin)\n// (1,2,3)\n\nIn case the RDD is empty, the csum, cmax and cmin will use the default values for the type of\nelements inside the RDD. There are counterpart operations to those that have an Option return type\nto deal with the case of an empty RDD:\nval data: RDD[(Int, Int, Int)] = sc.emptyRDD\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = EmptyRDD[15] at emptyRDD at :44\n\nprintln(data.csum)\n// (0,0,0)\n\nprintln(data.csumOption)\n// None\n\nprintln(data.cmax)\n// (0,0,0)\n\nprintln(data.cmaxOption)\n// None\n\nprintln(data.cmin)\n// (0,0,0)\n\nprintln(data.cminOption)\n// None\n\nThe following example aggregates all the elements with a common key.\ntype User = String\n// defined type alias User\n\ntype TransactionCount = Int\n// defined type alias TransactionCount\n\nval allData: RDD[(User,TransactionCount)] =\n sc.makeRDD((\"Bob\", 12) :: (\"Joe\", 1) :: (\"Anna\", 100) :: (\"Bob\", 20) :: (\"Joe\", 2) :: Nil)\n// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[16] at makeRDD at :47\n\nval totalPerUser = allData.csumByKey\n// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[17] at reduceByKey at implicits.scala:42\n\ntotalPerUser.collectAsMap\n// res16: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)\n\nThe same example would work for more complex keys.\nimport scala.collection.immutable.SortedMap\n// import scala.collection.immutable.SortedMap\n\nval allDataComplexKeu =\n sc.makeRDD( (\"Bob\", SortedMap(\"task1\" -> 10)) ::\n (\"Joe\", SortedMap(\"task1\" -> 1, \"task2\" -> 3)) :: (\"Bob\", SortedMap(\"task1\" -> 10, \"task2\" -> 1)) :: (\"Joe\", SortedMap(\"task3\" -> 4)) :: Nil )\n// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ParallelCollectionRDD[18] at makeRDD at :46\n\nval overalTasksPerUser = allDataComplexKeu.csumByKey\n// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ShuffledRDD[19] at reduceByKey at implicits.scala:42\n\noveralTasksPerUser.collectAsMap\n// res17: scala.collection.Map[String,scala.collection.immutable.SortedMap[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))\n\nJoins\n// Type aliases for meaningful types\ntype TimeSeries = Map[Int,Int]\n// defined type alias TimeSeries\n\ntype UserName = String\n// defined type alias UserName\n\nExample: Using the implicit full-our-join operator\nimport frameless.cats.outer._\n// import frameless.cats.outer._\n\nval day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 2, 1 -> 4)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Sam\", Map(0 -> 1)) :: Nil )\n// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[20] at makeRDD at :50\n\nval day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 10, 1 -> 11)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Joe\", Map(0 -> 1, 1 -> 2)) :: Nil )\n// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[21] at makeRDD at :50\n\nval daysCombined = day1 |+| day2\n// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[25] at mapValues at implicits.scala:67\n\ndaysCombined.collect()\n// res19: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))\n\nNote how the user's timeseries from different days have been aggregated together.\nThe |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join\non the key and combine values using the default Semigroup for the value type.\nIn cats:\nMap(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)\n// res20: Map[Int,Int] = Map(1 -> 6, 2 -> 2)\n\n"},"TypedML.html":{"url":"TypedML.html","title":"Using Spark ML with TypedDataset","keywords":"","body":"Typed Spark ML\nThe frameless-ml module provides a strongly typed Spark ML API leveraging TypedDatasets. It introduces TypedTransformers\nand TypedEstimators, the type-safe equivalents of Spark ML's Transformer and Estimator. \nA TypedEstimator fits models to data, i.e trains a ML model based on an input TypedDataset. \nA TypedTransformer transforms one TypedDataset into another, usually by appending column(s) to it.\nBy calling the fit method of a TypedEstimator, the TypedEstimator will train a ML model using the TypedDataset \npassed as input (representing the training data) and will return a TypedTransformer that represents the trained model. \nThis TypedTransformercan then be used to make predictions on an input TypedDataset (representing the test data) \nusing the transform method that will return a new TypedDataset with appended prediction column(s).\nBoth TypedEstimator and TypedTransformer check at compile-time the correctness of their inputs field names and types,\ncontrary to Spark ML API which only deals with DataFrames (the data structure with the lowest level of type-safety in Spark).\nframeless-ml adds type-safety to Spark ML API but stays very close to it in terms of abstractions and API calls, so \nplease check Spark ML documentation for more details \non Transformers and Estimators.\nExample 1: predict a continuous value using a TypedRandomForestRegressor\nIn this example, we want to predict the sale price of a house depending on its square footage and the fact that the house\nhas a garden or not. We will use a TypedRandomForestRegressor.\nTraining\nAs with the Spark ML API, we use a TypedVectorAssembler (the type-safe equivalent of VectorAssembler)\nto compute feature vectors:\nimport frameless._\nimport frameless.syntax._\nimport frameless.ml._\nimport frameless.ml.feature._\nimport frameless.ml.regression._\nimport org.apache.spark.ml.linalg.Vector\n\ncase class HouseData(squareFeet: Double, hasGarden: Boolean, price: Double)\n// defined class HouseData\n\nval trainingData = TypedDataset.create(Seq(\n HouseData(20, false, 100000),\n HouseData(50, false, 200000),\n HouseData(50, true, 250000),\n HouseData(100, true, 500000)\n))\n// trainingData: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]\n\ncase class Features(squareFeet: Double, hasGarden: Boolean)\n// defined class Features\n\nval assembler = TypedVectorAssembler[Features]\n// assembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@159b3f1\n\ncase class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector)\n// defined class HouseDataWithFeatures\n\nval trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures]\n// trainingDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]\n\nIn the above code snippet, .as[HouseDataWithFeatures] is a TypedDataset's type-safe cast\n(see TypedDataset: Feature Overview):\ncase class WrongHouseFeatures(\n squareFeet: Double,\n hasGarden: Int, // hasGarden has wrong type\n price: Double,\n features: Vector\n)\n\nassembler.transform(trainingData).as[WrongHouseFeatures]\n// :39: error: could not find implicit value for parameter as: frameless.ops.As[(Double, Boolean, Double, org.apache.spark.ml.linalg.Vector),WrongHouseFeatures]\n// assembler.transform(trainingData).as[WrongHouseFeatures]\n// ^\n\nMoreover, TypedVectorAssembler[Features] will compile only if Features contains exclusively fields of type Numeric or Boolean:\ncase class WrongFeatures(squareFeet: Double, hasGarden: Boolean, city: String)\n\nTypedVectorAssembler[WrongFeatures]\n// :37: error: Cannot prove that WrongFeatures is a valid input type. Input type must only contain fields of numeric or boolean types.\n// TypedVectorAssembler[WrongFeatures]\n// ^\n\nThe subsequent call assembler.transform(trainingData) compiles only if trainingData contains all fields (names and types)\nof Features:\ncase class WrongHouseData(squareFeet: Double, price: Double) // hasGarden is missing\n// defined class WrongHouseData\n\nval wrongTrainingData = TypedDataset.create(Seq(WrongHouseData(20, 100000)))\n// wrongTrainingData: frameless.TypedDataset[WrongHouseData] = [squareFeet: double, price: double]\n\nassembler.transform(wrongTrainingData)\n// :37: error: Cannot prove that WrongHouseData can be projected to Features. Perhaps not all member names and types of Features are the same in WrongHouseData?\n// assembler.transform(wrongTrainingData)\n// ^\n\nThen, we train the model. To train a Random Forest, one needs to feed it with features (what we predict from) and\nwith a label (what we predict). In our example, price is the label, features are the features:\ncase class RFInputs(price: Double, features: Vector)\n// defined class RFInputs\n\nval rf = TypedRandomForestRegressor[RFInputs]\n// rf: frameless.ml.regression.TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@4c620c93\n\nval model = rf.fit(trainingDataWithFeatures).run()\n// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.regression.TypedRandomForestRegressor.Outputs,org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anonfun$fit$1$$anon$1@36ed2d44\n\nTypedRandomForestRegressor[RFInputs] compiles only if RFInputs\ncontains only one field of type Double (the label) and one field of type Vector (the features):\ncase class WrongRFInputs(labelOfWrongType: String, features: Vector)\n\nTypedRandomForestRegressor[WrongRFInputs]\n// :37: error: Cannot prove that WrongRFInputs is a valid input type. Input type must only contain a field of type Double (the label) and a field of type org.apache.spark.ml.linalg.Vector (the features).\n// TypedRandomForestRegressor[WrongRFInputs]\n// ^\n\nThe subsequent rf.fit(trainingDataWithFeatures) call compiles only if trainingDataWithFeatures contains the same fields\n(names and types) as RFInputs.\nval wrongTrainingDataWithFeatures = TypedDataset.create(Seq(HouseData(20, false, 100000))) // features are missing\n// wrongTrainingDataWithFeatures: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]\n\nrf.fit(wrongTrainingDataWithFeatures) \n// :37: error: Cannot prove that HouseData can be projected to RFInputs. Perhaps not all member names and types of RFInputs are the same in HouseData?\n// rf.fit(wrongTrainingDataWithFeatures)\n// ^\n\nPrediction\nWe now want to predict price for testData using the previously trained model. Like the Spark ML API,\ntestData has a default value for price (0 in our case) that will be ignored at prediction time. We reuse\nour assembler to compute the feature vector of testData.\nval testData = TypedDataset.create(Seq(HouseData(70, true, 0)))\n// testData: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]\n\nval testDataWithFeatures = assembler.transform(testData).as[HouseDataWithFeatures]\n// testDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]\n\ncase class HousePricePrediction(\n squareFeet: Double,\n hasGarden: Boolean,\n price: Double,\n features: Vector,\n predictedPrice: Double\n)\n// defined class HousePricePrediction\n\nval predictions = model.transform(testDataWithFeatures).as[HousePricePrediction]\n// predictions: frameless.TypedDataset[HousePricePrediction] = [squareFeet: double, hasGarden: boolean ... 3 more fields]\n\npredictions.select(predictions.col('predictedPrice)).collect.run()\n// res6: Seq[Double] = WrappedArray(420000.0)\n\nmodel.transform(testDataWithFeatures) will only compile if testDataWithFeatures contains a field price of type Double\nand a field features of type Vector:\nmodel.transform(testData)\n// :37: error: Cannot prove that HouseData can be projected to RFInputs. Perhaps not all member names and types of RFInputs are the same in HouseData?\n// model.transform(testData)\n// ^\n\nExample 2: predict a categorical value using a TypedRandomForestClassifier\nIn this example, we want to predict in which city a house is located depending on its price and its square footage. We use a\nTypedRandomForestClassifier.\nTraining\nAs with the Spark ML API, we use a TypedVectorAssembler to compute feature vectors and a TypedStringIndexer\nto index city values in order to be able to pass them to a TypedRandomForestClassifier\n(which only accepts Double values as label):\nimport frameless.ml.classification._\n\ncase class HouseData(squareFeet: Double, city: String, price: Double)\n// defined class HouseData\n\nval trainingData = TypedDataset.create(Seq(\n HouseData(100, \"lyon\", 100000),\n HouseData(200, \"lyon\", 200000),\n HouseData(100, \"san francisco\", 500000),\n HouseData(150, \"san francisco\", 900000)\n))\n// trainingData: frameless.TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]\n\ncase class Features(price: Double, squareFeet: Double)\n// defined class Features\n\nval vectorAssembler = TypedVectorAssembler[Features]\n// vectorAssembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@66b12f1\n\ncase class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector)\n// defined class HouseDataWithFeatures\n\nval dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures]\n// dataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]\n\ncase class StringIndexerInput(city: String)\n// defined class StringIndexerInput\n\nval indexer = TypedStringIndexer[StringIndexerInput]\n// indexer: frameless.ml.feature.TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@666bcbec\n\nval indexerModel = indexer.fit(dataWithFeatures).run()\n// indexerModel: frameless.ml.AppendTransformer[StringIndexerInput,frameless.ml.feature.TypedStringIndexer.Outputs,org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anonfun$fit$1$$anon$1@5a0797e\n\ncase class HouseDataWithFeaturesAndIndex(\n squareFeet: Double,\n city: String,\n price: Double,\n features: Vector,\n cityIndexed: Double\n)\n// defined class HouseDataWithFeaturesAndIndex\n\nval indexedData = indexerModel.transform(dataWithFeatures).as[HouseDataWithFeaturesAndIndex]\n// indexedData: frameless.TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]\n\nThen, we train the model:\ncase class RFInputs(cityIndexed: Double, features: Vector)\n// defined class RFInputs\n\nval rf = TypedRandomForestClassifier[RFInputs]\n// rf: frameless.ml.classification.TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@be7eeed\n\nval model = rf.fit(indexedData).run()\n// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.classification.TypedRandomForestClassifier.Outputs,org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anonfun$fit$1$$anon$1@20355c2f\n\nPrediction\nWe now want to predict city for testData using the previously trained model. Like the Spark ML API,\ntestData has a default value for city (empty string in our case) that will be ignored at prediction time. We reuse\nour vectorAssembler to compute the feature vector of testData and our indexerModel to index city.\nval testData = TypedDataset.create(Seq(HouseData(120, \"\", 800000)))\n// testData: frameless.TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]\n\nval testDataWithFeatures = vectorAssembler.transform(testData).as[HouseDataWithFeatures]\n// testDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]\n\nval indexedTestData = indexerModel.transform(testDataWithFeatures).as[HouseDataWithFeaturesAndIndex]\n// indexedTestData: frameless.TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]\n\ncase class HouseCityPredictionInputs(features: Vector, cityIndexed: Double)\n// defined class HouseCityPredictionInputs\n\nval testInput = indexedTestData.project[HouseCityPredictionInputs]\n// testInput: frameless.TypedDataset[HouseCityPredictionInputs] = [features: vector, cityIndexed: double]\n\ncase class HouseCityPredictionIndexed(\n features: Vector,\n cityIndexed: Double,\n rawPrediction: Vector,\n probability: Vector,\n predictedCityIndexed: Double\n)\n// defined class HouseCityPredictionIndexed\n\nval indexedPredictions = model.transform(testInput).as[HouseCityPredictionIndexed]\n// indexedPredictions: frameless.TypedDataset[HouseCityPredictionIndexed] = [features: vector, cityIndexed: double ... 3 more fields]\n\nThen, we use a TypedIndexToString to get back a String value from predictedCityIndexed. TypedIndexToString takes\nas input the label array computed by our previous indexerModel:\ncase class IndexToStringInput(predictedCityIndexed: Double)\n// defined class IndexToStringInput\n\nval indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)\n// indexToString: frameless.ml.feature.TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@c97d749\n\ncase class HouseCityPrediction(\n features: Vector,\n cityIndexed: Double,\n rawPrediction: Vector,\n probability: Vector,\n predictedCityIndexed: Double,\n predictedCity: String\n)\n// defined class HouseCityPrediction\n\nval predictions = indexToString.transform(indexedPredictions).as[HouseCityPrediction]\n// predictions: frameless.TypedDataset[HouseCityPrediction] = [features: vector, cityIndexed: double ... 4 more fields]\n\npredictions.select(predictions.col('predictedCity)).collect.run()\n// res8: Seq[String] = WrappedArray(san francisco)\n\nList of currently implemented TypedEstimators\n\nTypedRandomForestClassifier\nTypedRandomForestRegressor\n... your contribution here ... :)\n\nList of currently implemented TypedTransformers\n\nTypedIndexToString\nTypedStringIndexer\nTypedVectorAssembler\n... your contribution here ... :)\n\nUsing Vector and Matrix with TypedDataset\nframeless-ml provides TypedEncoder instances for org.apache.spark.ml.linalg.Vector \nand org.apache.spark.ml.linalg.Matrix:\nimport frameless._\nimport frameless.ml._\nimport org.apache.spark.ml.linalg._\n\nval vector = Vectors.dense(1, 2, 3)\n// vector: org.apache.spark.ml.linalg.Vector = [1.0,2.0,3.0]\n\nval vectorDs = TypedDataset.create(Seq(\"label\" -> vector))\n// vectorDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Vector)] = [_1: string, _2: vector]\n\nval matrix = Matrices.dense(2, 1, Array(1, 2))\n// matrix: org.apache.spark.ml.linalg.Matrix =\n// 1.0\n// 2.0\n\nval matrixDs = TypedDataset.create(Seq(\"label\" -> matrix))\n// matrixDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Matrix)] = [_1: string, _2: matrix]\n\nUnder the hood, Vector and Matrix are encoded using org.apache.spark.ml.linalg.VectorUDT \nand org.apache.spark.ml.linalg.MatrixUDT. This is possible thanks to the implicit derivation \nfrom org.apache.spark.sql.types.UserDefinedType[A] to TypedEncoder[A] defined in TypedEncoder companion object.\n"},"TypedDataFrame.html":{"url":"TypedDataFrame.html","title":"Proof of Concept: TypedDataFrame","keywords":"","body":"Proof of Concept: TypedDataFrame\nTypedDataFrame is the API developed in the early stages of Frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future development of Frameless. However, the design is interesting enough to document.\nTo safely manipulate DataFrames we use a technique called a shadow type, which consists in storing additional information about a value in a \"dummy\" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.\nDiving in\nIn TypedDataFrame, we use a single Schema to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:\nimport org.apache.spark.sql.DataFrame\nimport shapeless.HList\n\nclass TDataFrame[Schema Boolean): TDataFrame[Schema] = ???\n\n def select[C \nAs you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.\nType-level column referencing\nFor Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching invalid column references compile type. When everything goes well, Frameless select is very similar to vanilla select, except that it keeps track of the selected column types:\nimport frameless.TypedDataFrame\n\ncase class Foo(s: String, d: Double, i: Int)\n\ndef selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n tf.select('i, 's)\n\nHowever, in case of typo, it gets caught right away:\ndef selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n tf.select('j, 's)\n\nType-level joins\nJoins can available with two different syntaxes. The first lets you reference different columns on each TypedDataFrame, and ensures that they all exist and have compatible types:\ncase class Bar(i: Int, j: String, b: Boolean)\n\ndef join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =\n tf1.innerJoin(tf2).on('s).and('j)\n\nThe second syntax brings some convenience when the joining columns have identical names in both tables:\ndef join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n : TypedDataFrame[(String, Double, Int, String, Boolean)] =\n tf1.innerJoin(tf2).using('i)\n\nFurther example are available in the TypedDataFrame join tests.\nComplete example\nWe now consider a complete example to see how the Frameless types can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city maps and neighborhoods:\ntype Neighborhood = String\ntype Address = String\n\ncase class PhoneBookEntry(\n address: Address,\n residents: String,\n phoneNumber: Double\n)\n\ncase class CityMapEntry(\n address: Address,\n neighborhood: Neighborhood\n)\n\nOur goal will be to compute the neighborhood with unique names, approximating \"unique\" with names containing less common\nletters in the alphabet: 'x', 'q', and 'z'. We are going to need a natural language processing library at some point, so\nlet's use the following for the example:\nobject NLPLib {\n def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))\n}\n\nSuppose we manage to obtain public data for a TypedDataFrame[PhoneBookEntry] and TypedDataFrame[CityMapEntry]. Here is what our Spark job could look like with Frameless:\nimport org.apache.spark.sql.SQLContext\n\n// These case classes are used to hold intermediate results\ncase class Family(residents: String, neighborhood: Neighborhood)\ncase class Person(name: String, neighborhood: Neighborhood)\ncase class NeighborhoodCount(neighborhood: Neighborhood, count: Long)\n\ndef bestNeighborhood\n (phoneBookTF: TypedDataFrame[PhoneBookEntry], cityMapTF: TypedDataFrame[CityMapEntry])\n (implicit c: SQLContext): String = {\n (((((((((\n phoneBookTF\n .innerJoin(cityMapTF).using('address) :TypedDataFrame[(Address, String, Double, String)])\n .select('_2, '_4) :TypedDataFrame[(String, String)])\n .as[Family]() :TypedDataFrame[Family])\n .flatMap { f =>\n f.residents.split(' ').map(r => Person(r, f.neighborhood))\n } :TypedDataFrame[Person])\n .filter { p =>\n NLPLib.uniqueName(p.name)\n } :TypedDataFrame[Person])\n .groupBy('neighborhood).count() :TypedDataFrame[(String, Long)])\n .as[NeighborhoodCount]() :TypedDataFrame[NeighborhoodCount])\n .sortDesc('count) :TypedDataFrame[NeighborhoodCount])\n .select('neighborhood) :TypedDataFrame[Tuple1[String]])\n .head._1\n}\n\nIf you compare this version to vanilla Spark where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.\nLimitations\nThe main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.\nIn the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in Frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.\n"}}} \ No newline at end of file +{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["\"0.9.0\"","\"_1\".","\"frameless","\"org.typelevel\"","\"value\"","%","%%","(e.g.","(e.g.,","(includ","(peopl","(thumb",")","++=","+1,","//","0","0.13.13:","0.4","0.4.0","0.4.1","0.5.2","0.5.x","0.6.1","0.6.x","0.7.0","0.8","0.8.0","0.9","0.9.0","0.9.x","1.0.0","1.x","2.0","2.0,","2.11","2.11/2.12","2.12","2.12.x.","2.2.0","2.2.1","2.3.0","2.3.0.","2.3.1","2.3.2.","2.4.0","20","3","3.0.0","=",">=","access","add","adelbertc","adjust","aforement","against","allow","apach","api","api,","api.","appli","applic","approach,","are:","arithmet","associ","avail","avoid","base","benefit","bootstrap","break","bring","build.sbt","built","call","cast","cat","cats\"","cats.","chang","channel","choos","click","code","collect","column","column,","columns)","compar","comparison","compat","compil","compile)","concept:","conduct","consist","consol","contain","contribut","contributor","creat","current","custom","customizable,","dataframe'","dataset","dataset\"","dataset,","dataset/datafram","default","depend","detail","develop","document","easi","effect","effect,","encod","encoder,","enhanc","environ","error","error)","essenti","exist","express","expressionencod","featur","features.","feel","few","file","file.","first","follow","follows:","frameless","frameless_gen_min_s","frameless_gen_size_rang","framelessvers","framelessversion,","free","friendli","function","g8","gener","get","giter8","github,","gitter","gitter)","ground,","help?","here","http://opensource.org/licenses/apach","ident","imario","imarios/frameless.g8","injection:","insid","instal","intention","introduc","introduct","issues/questions.","jar.","job[a]","kanterov","learning.","librari","librarydepend","licens","list(","load","made","maintain","merg","messag","minim","ml","ml\"","modul","modules:","more","need","needed:","new","next","non","note","now","numer","offici","olivierblanvillain","on","oper","outofmemoryerrors,","overhead","overview","possibl","prefer","probabl","project","project:","proof","properti","provid","pull","quick","rdd","rdds,","referenc","release,","requests)","requests.","requir","runtim","safe","same","sbt","scala","schema","second","set","sever","shapeless","shell","sign","signatur","similar)","simpli","simply:","singl","size","sizes.","spark","spark'","spark).","spark.","standard","start","still","strongli","suite:","support","tabl","test","tests.","therefore,","tune","type","typeddatafram","typeddataset","typeddataset.","typeddataset:","typelevel","types.","typesaf","under","up","up,","us","val","valu","variabl","veri","version","versions.","want","way","well","well.","why?","with,","work"],"FeatureOverview.html":["\"a","\"abc\")","\"false\")","\"lyon\",","\"paris\")","\"paris\",","$\"*\".","'`citi`'","'city),","'name),","'null'","'population)","'price),","'project","(apttypedds)","(apttypedds2)","(column:","(e.g.,","(enjoy","(frameless.typedcolumn[(string,","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(from","(i.e.,","(if","(in","(int)","(lyon,166500.0))","(name:","(or","(paris,333333.3333333333),","(short","(string,","(such","(u:","(up","(which","(with",")",").as[apartmentdetails]",").as[aptpricecity].show().run",").as[stats].show().run()",").show().run()",").show(1).run()",").show(2).run()","*","+","...","...).",".ac",".dataset",".desc.",".flattenopt",".select($\"*\",","/","//","0.0|","0.0|325000.0|","0.2,","1","1),","1.1|","10","10),","10,","100,","10000.0,","102|","133000...|","133000.0,","133000.0|","1|","1|250000.0|","2","2)","2)).","2)).show().run()","2),","2).as[updatedsurface]","2).show().run()","2).show(2).run()","2.0","200000...|","200000.0,","200000.0|","2229621),","2229621|","2229621}|","2409.6385542168673,","25,","25000...|{paris,","250000.0,","250000.0|","250|","25|[paris,","27|","2955.5555555555557,","2:","2|","2|300000.0|","2|[a,","2}|[a,","3","3)","3),","30000...|{paris,","300000.0,","300000.0|","325000...|","325000.0,","325000.0|","343629)","343629|","343629}|","3|","3|450000.0|","3|[a,","4","42","4391.891891891892)","4391.891891891892|","45,","4500...|{paris,","4500.0,","450000.0,","450000.0|","450|","45|133000.0|","47|","4|","50,","500715),","500715|","500715}|","500|","50|300000.0|","52|","6833.333333333333|","74,","740|","76|","83,","830|","83|200000.0|","85|","9000.0|",":",":26:",":27:",":28:",":29:",":35:",":36:","=","==","===","=>","['citi]","[1...10]).","[_1:","[bedrooms,","[city#1384,","[city:","[out,","[ratio:","[tt,","[value:","^","_1.","_1|","_2:","_2|","_3|","_4|","a)(implicit","a,","ab","abov","access","accident","action","actual","ad","adapt","add","added,","addit","addition,","address","adjustedpric","adjustedprice.show().run()","adjustedprice:","advanc","again","agg()","agg(avg(aptds('price))).","aggreg","aggregated,","agree.","align","align.","allcities:","allcities|","allow","allowed,","allowed:","alternatives:","and/or","anoth","anyth","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartment.","apartmentdetail","apartmentdetails(city:","apartmentdetails?","apartmentopt(city:","apartmentopt(none,","apartmentopt(some(\"paris\"),","apartmentshortinfo","apartmentshortinfo(city:","apartmentshortinfo?","apartmentsopt","api","api,","api.","apis),","appear","appli","aptd","aptds('city),","aptds('price)","aptds('price)))","aptds('price),","aptds('surface),","aptds('surface).cast[double]","aptds('surface).cast[double])","aptds.","aptds.agg(","aptds.select(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)","apttypedds('city)).as[updatedsurface]","apttypedds('city).asc,","apttypedds('city).cast[double]","apttypedds('price).desc","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.joininner(citiinfotypedds)","apttypedds.makeudf(pricemodifier)","apttypedds.orderby(","apttypedds.orderby(apttypedds('city).asc).show(2).run()","apttypedds.project[apartmentshortinfo]","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds.union(apttypedds2).show().run","apttypedds2","apttypedds2('price)","apttypedds2('price)).","apttypedds2.drop[citybeds]","apttypedds2.droptupled('price):","apttypedds2.union(apttypedds).show().run","apttypedds2.withcolumnreplaced('price,","apttypedds2.withcolumntupled(","apttypedds2.withcolumntupled(lit(array(\"a\",\"b\",\"c\"))).show(2).run()","apttypedds2:","apttypedds:","apttypeddsopt","apttypeddsopt('surface)","apttypeddsopt('surface).opt.map(_","apttypeddsopt.select(apttypeddsopt('surface)","apttypeddsopt.select(apttypeddsopt('surface).opt.map(c","apttypeddsopt.show().run()","apttypeddsopt:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","argument","arguments)","around","array]","arraycontains(t('_1),","arraycontains(t('_2),","arraycontains:","as:","as[bedroomstats]","as[t]","ascol","ascol()","assum","automat","avail","available.","averag","avg","avg(aptds('price))","avg(aptds('price)),","avg(aptds('surface))","avg(aptds('surface)),","avgprice:","avgpricebeds1:","avgpricebeds2:","avgpricebeds3:","avgpricebeds4:","avgprice|","avgsurface:","avgsurface|minsurface|","b,","base","becom","bedroom","bedrooms#1387]","bedrooms.","bedrooms:","bedroomstat","bedroomstats(","bedroomstats('avgpricebeds2).getorelse(0.0),","bedroomstats('avgpricebeds3).getorelse(0.0))","bedroomstats(lyon,some(133000.0),some(200000.0),none,none)","bedroomstats(nice,none,none,some(325000.0),none)","bedroomstats(paris,some(250000.0),some(300000.0),some(450000.0),none)","bedroomstats.collect().run().foreach(println)","bedroomstats.dataset.todf().filter($\"avgpricebeds2\".isnotnull)","bedroomstats.flattenoption('avgpricebeds2)","bedroomstats.select(","bedroomstats.show().run()","bedroomstats:","behavior","bellow:","below.","best","better","between","boolean","boolean)].","bypass","c","c('_2)).show(2).run()","c,","c.","c.select(c.colmany('_1,","c.show(1).run()","c:","c]|","calcul","call","caller","can't","care","case","case,","cases.","cast","cast,","catalystcast.","catalystcast[string,","chang","change.","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name)","city,","city:","cityb","citybeds(city:","citybeds(lyon,2))","citybeds(paris,1))","citybeds(paris,1),","citybeds(paris,3))","citybeds(paris,3),","citybeds.","citybeds.head(3).run()","citybeds.headoption.run()","citybeds.limit(4).collect().run()","citybeds.select(citybeds.ascol,","citybeds.take(2).run()","citybeds:","citybedsoth","citybedsother(city:","cityinfo","cityinfo(city:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.select(cityratio('city),","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|avgpricebeds1|avgpricebeds2|avgpricebeds3|avgpricebeds4|","city|bedrooms|","city|surface|","class","class:","claus","clause.","code","collect","collect())","collection,","collectset(aptds('city))","colmany()","column","column\")","column,","column.","column:","columns,","columns.","columns:","combin","common","compar","compat","compil","compile,","compile.","compile:","compiles:","complet","complex","comput","computations.","concat,","condition","conf","contain","context","continu","convention.","convert","correspond","count,","creat","d]|true|","data","dataframe,","dataframes,","dataset","dataset.","dataset:","deal","defin","design,","detail","directli","divid","divided,","done","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","drop","drop().","drop/replace/add","droptupled()","e.g.,","e:","each","easier","easili","element","elements.","elid","empti","encod","entir","equival","equivelantli","error","error.","error:","etc.).","evid","evidence$1:","exactli","exampl","example,","example.","except","exist","expect","explan","explicitli","explode()","explode(_2)","explode(_2),","expos","express","expression'","extra","fail","faster","featur","few","field","field]","fields.","fields]","finally,","find","first","five","flatten","flattened.show(4).run()","flattened:","flattenstat","flattenstats:","follow","form","formal","found","frameless","frameless'","frameless,","frameless.abstracttypedcolumn[?t,?c[?a]]","frameless.abstracttypedcolumn[t,c[a]]","frameless.abstracttypedcolumn[t,c[a]],","frameless.catalystcast[string,double]","frameless.catalystcollection[c])column.thistype[t,boolean]","frameless.catalystdivisible[double,out],","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.catalystnumeric[option[int]])frameless.typedcolumn[apartmentopt,option[int]]","frameless.catalystnumeric[option[int]],","frameless.functions._","frameless.functions.aggregate._","frameless.functions.lit","frameless.functions.nonaggregate._","frameless.functions.nonaggregate.when","frameless.functions.udf$$lambda$12549/0x0000000803898840@61521397","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[(string,","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[tt,double])(implicit","frameless.typedcolumn[tt,option[int]])(implicit","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(citybeds,","frameless.typeddataset[(double,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[apartmentopt]","frameless.typeddataset[apartmentshortinfo]","frameless.typeddataset[bedroomstats]","frameless.typeddataset[citybeds]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[this.out]","frameless.typeddataset[updatedsurface]","frameless.typedencoder[out],","frameless.with[apartment,tt]{typ","frameless.with[apartmentopt,tt]{typ","function","functions.","further","gener","get","getorelse().","give","given","group","groupbi","groupby()","groupby(aptds('city)).","hand","harder","help","here","here.","here:","however,","id","if(nam","ignor","imperfections,","implement","implicit","import","includ","inflat","inflation.show(2).run()","inflation:","inform","initi","input","instanc","instance,","instances:","instanti","instead","instead.","int","int)","int).","int)]","int,","int.","int]","interest","introduc","issue,","issue:","it'","job","join","known","later","lazi","lazy.","let","let'","lift","list[int])]","list[string])","list[string]),string]","list[string]),string],","list[string])]","lit(0.001))","lit(1.1)).","lit(list(\"a\",\"b\",\"c\")))","lit(list(\"abc\",\"c\",\"d\")))","lit(list(1,2,3,4)))","litaggr(\"hello","liter","localrel","long","long,","look","lose","lyon]|","lyon|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","macro","main","make","mani","map()","match","materialize.","math","matter","member","method","method.","min(aptds('surface)),","min(aptds('surface)).cast[double],","minimum","minsurface:","mismatch;","miss","missing,","misspel","mistak","more","multipl","n","n:","name","name:","names/typ","names/types,","need","nest","new","next","next,","nice,","nice|","nice|325000.0|","non","none","none),","none).","none,","not,","note","now","null).","null|","null|450000.0|","number","often,","on","on(1,2,3,4).","oper","operation.","operations:","opt","option","option.","option[citybeds]","option[double]","option[double])","option[double])]","option[double],","option[int])","option[int])(implicit","option[int],","option[string],","option[x]","options.","order","order.","org.apache.spark.sql,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$$anonfun$apply$22.applyorelse(analyzer.scala:2503)","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$$anonfun$apply$22.applyorelse(analyzer.scala:2510)","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$.apply(analyzer.scala:2447)","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$.apply(analyzer.scala:2503)","org.apache.spark.sql.catalyst.analysis.analyzer.$anonfun$executeandcheck$1(analyzer.scala:173)","org.apache.spark.sql.catalyst.analysis.analyzer.$anonfun$executeandcheck$1(analyzer.scala:175)","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.analyzer.execute(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.analyzer.execute(analyzer.scala:189)","org.apache.spark.sql.catalyst.analysis.analyzer.executeandcheck(analyzer.scala:172)","org.apache.spark.sql.catalyst.analysis.analyzer.org$apache$spark$sql$catalyst$analysis$analyzer$$executesamecontext(analyzer.scala:195)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$$nestedinanonfun$checkanalysis$1$2.applyorelse(checkanalysis.scala:152)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$$nestedinanonfun$checkanalysis$1$2.applyorelse(checkanalysis.scala:155)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1$adapted(checkanalysis.scala:93)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1(checkanalysis.scala:152)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkanalysis$(checkanalysis.scala:90)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkanalysis(checkanalysis.scala:93)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.plans.logical.analysishelper$.allowinvokingtransformsinanalyzer(analysishelper.scala:221)","org.apache.spark.sql.catalyst.plans.logical.analysishelper$.markinanalyzer(analysishelper.scala:228)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.$anonfun$resolveoperatorsup$1(analysishelper.scala:90)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.$anonfun$resolveoperatorsup$3(analysishelper.scala:90)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.resolveoperatorsup$(analysishelper.scala:84)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.resolveoperatorsup(analysishelper.scala:86)","org.apache.spark.sql.catalyst.plans.logical.logicalplan.resolveoperatorsup(logicalplan.scala:29)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$1(queryplan.scala:116)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$3(queryplan.scala:132)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$4(queryplan.scala:137)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$transformexpressionsup$1(queryplan.scala:104)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:137)","org.apache.spark.sql.catalyst.plans.queryplan.recursivetransform$1(queryplan.scala:127)","org.apache.spark.sql.catalyst.plans.queryplan.recursivetransform$1(queryplan.scala:132)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:116)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:104)","org.apache.spark.sql.catalyst.queryplanningtracker$.withtracker(queryplanningtracker.scala:88)","org.apache.spark.sql.catalyst.queryplanningtracker.measurephase(queryplanningtracker.scala:111)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$execute$1$adapted(ruleexecutor.scala:205)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$execute$1(ruleexecutor.scala:213)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$execute$2(ruleexecutor.scala:216)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$executeandtrack$1(ruleexecutor.scala:183)","org.apache.spark.sql.catalyst.rules.ruleexecutor.execute(ruleexecutor.scala:205)","org.apache.spark.sql.catalyst.rules.ruleexecutor.executeandtrack(ruleexecutor.scala:183)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:73)","org.apache.spark.sql.catalyst.trees.treenode.$anonfun$transformup$2(treenode.scala:341)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:183)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:243)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:341)","org.apache.spark.sql.dataset$.$anonfun$ofrows$1(dataset.scala:90)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:88)","org.apache.spark.sql.dataset.select(dataset.scala:1462)","org.apache.spark.sql.dataset.withplan(dataset.scala:3715)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.dataset[org.apache.spark.sql.row]","org.apache.spark.sql.errors.querycompilationerrors$.morethanonegeneratorerror(querycompilationerrors.scala:95)","org.apache.spark.sql.execution.queryexecution.$anonfun$analyzed$1(queryexecution.scala:73)","org.apache.spark.sql.execution.queryexecution.$anonfun$executephase$1(queryexecution.scala:143)","org.apache.spark.sql.execution.queryexecution.analyzed$lzycompute(queryexecution.scala:73)","org.apache.spark.sql.execution.queryexecution.analyzed(queryexecution.scala:71)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:63)","org.apache.spark.sql.execution.queryexecution.executephase(queryexecution.scala:143)","org.apache.spark.sql.functions.{explod","org.apache.spark.sql.sparksess","org.apache.spark.sql.sparksession.withactive(sparksession.scala:772)","org.apache.spark.{sparkconf,","origin","other:","otherwise(lit(0.0))).show(8).run()","other|","out","overload","overview","paramet","part","particular","per","perform","perhap","pivot","pivot(aptds('bedrooms)).","pivot,","popul","population:","potenti","prefer","preserv","previou","price","price#1386,","price,","price/surfac","price:","price:double)","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.select(pricebysurfaceunit.ascol","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","price|bedrooms|","problem","project","project,","prove","provid","rais","ratio","ratio:","ratio|","readi","real","recommend","refer","referenc","reflect","remov","repl\").set(\"spark.ui.enabled\",","replac","repres","requir","required:","res18:","res20:","res30:","res31:","res32:","res33:","res38:","res45:","res46:","res4:","resolv","result","result.","retriev","return","right?","row","run()","runtim","safe","safe,","safe.","safeti","safety,","safety.","same","samplestat","samplestats.show().run()","samplestats:","scala","scala,","scala.collection.abstracttraversable.map(traversable.scala:108)","scala.collection.immutable.list.foldleft(list.scala:91)","scala.collection.immutable.list.foreach(list.scala:431)","scala.collection.linearseqoptimized.foldleft$(linearseqoptimized.scala:122)","scala.collection.linearseqoptimized.foldleft(linearseqoptimized.scala:126)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:49)","scala.collection.mutable.resizablearray.foreach$(resizablearray.scala:55)","scala.collection.mutable.resizablearray.foreach(resizablearray.scala:62)","scala.collection.traversablelike.$anonfun$map$1(traversablelike.scala:285)","scala.collection.traversablelike.map$(traversablelike.scala:278)","scala.collection.traversablelike.map(traversablelike.scala:285)","scala.reflect.classtag[option[int]])frameless.typedcolumn[w,option[int]]","scala>","scalar","scalar,","schema","schema.","second","secondari","see","seem","select","select()","select().","selectmany()","selectmany(),","seq(","seq[(string,","seq[citybeds]","seq[double]","set","shapeless.tag.tagged[string(\"citi\")]","shorter","show","show()","show(1).run()","shown","similar","similarly,","simpl","simplifi","since,","singl","skip","some(10).map(c","some(3))","some(300000.0),","some(450000.0),","some(50),","some(citybeds(paris,2))","sort","sorting.","sourc","spark","spark'","spark,","spark.","spark.createdataset(apartments)","spark.implicits._","spark.sparkcontext.setloglevel(\"warn\")","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparkexplode($\"_2\"))","sparkexplode}","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","stack","standard","start","stat","statement","stats(","string","string(\"abc\")","string)","string),updatedsurface]","string,","string.","string]","struct,","struct]","subset","such","suffer","suggests,","sum,","support","suppos","surfac","surface#1385,","surface,","surface:","surface];","symbol","syntax","syntax:","t","t.withcolumntupled(","t2","t2.dataset.todf().select(sparkexplode($\"_2\"),","t2.explode('_2):","t2:","t:","take","tell","those","three","throw","time","time,","time.","top","topic","trace):","transform","transformations.","tri","tt,","tupl","tutori","tutorial.","two","type","type)","type:","type;","typedaggreg","typedcolumn","typeddataset","typeddataset.","typeddataset.create(apartments)","typeddataset.create(apartmentsopt)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[(string,int)]","typeddataset[a]","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[apartmentshortinfo]","typeddataset[citybeds]","typeddataset[double])","typeddataset[long].","typeddataset[string]","typeddataset[t]","typeddataset[tuple1[a]].","typeddataset[tuple1[long]]","typeddataset[tuplen[...]]","typeddataset[u]","typeddatset.","types,","typesaf","typesafeti","typo","u","udf","udf()","udf().","udf(aptds('city),","udf:","underli","unfortun","union","unit:","unlik","unsaf","unwrap","up","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","usag","user","val","valid","valu","value.","value:","values.","value|","vanilla","vector[string])","verifi","w:","w](other:","want","way","way,","well.","when(apttypedds2('city)","when/otherwis","whenev","wherea","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withcolumn()","withcolumn[citybedsother](lit(list(\"a\",\"b\",\"c\"))).","withcolumntupled()","without","work","worked,","world\")","world|","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","wrappedarray(citybeds(paris,2),","written","w})frameless.typedcolumn[w,option[int]]","w})frameless.typedcolumn[w,out]","w},","x.","{","{lyon,","{nice,","|","|1000|102|","|12000.0|","|200000.0|","|276333.3333333333|62.833333333333336|","|300000.0|450000.0|","|4500.0|450000.0|","|6000.0|300000.0|","|6908333.333333333|12.566666666666668|hello","|city|surface|","|lyon|","|null|null|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|paris|[a,","|paris|[abc,","|{lyon,","|{nice,","|{paris,","}"],"TypedDatasetVsSparkDataset.html":["\"e\")","\"java.util.date\",","\"jday\")","\"mydate\"","\"q\")","\"w\")","$\"i\"*2)","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","'(sum(`i`)","'`i`'","'`x`'","'project","(case","(class:","(i","(i#23l","(int,","(isnotnull(i#23l)","(look","(or","(see","(the",")","*","*(1)","+",",","...",".appli","//","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10).select(fds('i)).explain()","10).select(fds('i)).show().run()","10).select(fds('x))","10)],","10|","133|","1|","2)#165l]","42",":",":20:",":24:",":25:",":26:","::","=","==","===","=>","['x]","[],","[a]frameless.typedcolumn[foo,a]","[i#23l","[i#23l,j#24]","[i#23l]","[i,","[i:","[input[0,","[isnotnull(i#23l),","[isnotnull(i),","[out]frameless.typedaggregate[foo,out]","[sum(i#23l)","^","`sum(i)`)'","above.","access","achiev","act","ad","aggreg","allow","api","appli","applications.","area","argument","as[long]","assum","averaging,","avoid","bar","bar(1)))","bar(i:","bar.","batched:","before.","between","bigint","bigint))","bigint,","bigint]","bind","both","bug","bulletproof:","captur","care","case","cast","cast(10","cast(2","catalyst","class","class:","classes)","clearli","closur","closures.","code","code.","column","columnar","columnartorow","columns,","columns:","compar","comparison,","compil","compromis","confus","content","context","correct.","correctli","creat","current","datafilters:","dataset","dataset.","dataset[long].","datasets,","defin","deserializetoobject","detail.","detect","differ","discuss","discussion.","disk","distinguish","don't","ds","ds.filter($\"i\"","ds.filter(_.i","ds.select(sum($\"i\"),","ds.show()","ds:","each","elid","empty,","encod","encoder:","encoder[bar]","entir","equalto(i,10)],","error","error.","error:","etc)","exampl","example,","exist","expect","explain","explicitli","express","extrem","e|","fail","failure:","false]","familiar","fd","fds('i)).show().run()","fds.agg(fsum(fds('i))+22).show().run()","fds.agg(fsum(fds('i)),","fds.filter(fds('i)","fds.select(fsum(fds('i)))","fds:","few","field","fields.","file","file.","filescan","filter","filteredd","filteredds.explain()","filteredds.show()","filteredds:","find","first","first()","first,","first_value)","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo,","foo.","format","format:","found","frameless","frameless'","frameless,","frameless.functions.aggregate.{sum","frameless.functions.aggregate.{sum=>fsum}","frameless.syntax._","frameless.typedaggregate[foo,?]","frameless.typedcolumn[foo,?]","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[mydate]","frameless:","friend.","fsum}","fulli","function","function(s)","function.","futur","generated.","get.;","give","given","goal:","great!","group","guard","handhold","help","here","here.","hold","however,","implement","implicit","import","improv","incompat","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inmemoryfileindex[file:/tmp/foo],","input","insid","instanc","instanti","instead.","int)","introduc","intuitively,","it'","i|","j.","j:","j];","java.lang.unsupportedoperationexception:","java.util.d","java.util.date(system.currenttimemillis))))","java.util.date)","j|","know","last","lead","let'","limit","line","linux","load","location:","long","long,","look","mac","make","map","mapel","member","members.","mention","method","mistak","mix","more","mydat","mydate(jday:","name","name:","need","newinstance(class","next","nil","non","note","notifi","now,","obj#72:","obj#73:","ok","on","oper","operations,","optim","optimizer)","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.$anonfun$executeandcheck$1(analyzer.scala:175)","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.analyzer.executeandcheck(analyzer.scala:172)","org.apache.spark.sql.catalyst.analysis.analyzer.failanalysis(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$$nestedinanonfun$checkanalysis$1$2.applyorelse(checkanalysis.scala:152)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$$nestedinanonfun$checkanalysis$1$2.applyorelse(checkanalysis.scala:155)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1$adapted(checkanalysis.scala:93)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1(checkanalysis.scala:152)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1(checkanalysis.scala:299)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$12$adapted(checkanalysis.scala:272)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$12(checkanalysis.scala:272)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$15$adapted(checkanalysis.scala:299)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$15(checkanalysis.scala:299)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkanalysis$(checkanalysis.scala:90)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkanalysis(checkanalysis.scala:93)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkvalidaggregateexpression$1(checkanalysis.scala:263)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkvalidaggregateexpression$1(checkanalysis.scala:272)","org.apache.spark.sql.catalyst.analysis.checkanalysis.failanalysis$(checkanalysis.scala:49)","org.apache.spark.sql.catalyst.analysis.checkanalysis.failanalysis(checkanalysis.scala:50)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:56)","org.apache.spark.sql.catalyst.plans.logical.analysishelper$.markinanalyzer(analysishelper.scala:228)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$1(queryplan.scala:116)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$3(queryplan.scala:132)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$4(queryplan.scala:137)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$transformexpressionsup$1(queryplan.scala:104)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:137)","org.apache.spark.sql.catalyst.plans.queryplan.recursivetransform$1(queryplan.scala:127)","org.apache.spark.sql.catalyst.plans.queryplan.recursivetransform$1(queryplan.scala:132)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:116)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:104)","org.apache.spark.sql.catalyst.queryplanningtracker.measurephase(queryplanningtracker.scala:111)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$1(scalareflection.scala:562)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$1(scalareflection.scala:591)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$6(scalareflection.scala:577)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfortype$1(scalareflection.scala:421)","org.apache.spark.sql.catalyst.scalareflection$.cleanupreflectionobjects(scalareflection.scala:49)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:432)","org.apache.spark.sql.catalyst.scalareflection$.serializerfortype(scalareflection.scala:413)","org.apache.spark.sql.catalyst.scalareflection.cleanupreflectionobjects$(scalareflection.scala:903)","org.apache.spark.sql.catalyst.scalareflection.cleanupreflectionobjects(scalareflection.scala:904)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:73)","org.apache.spark.sql.catalyst.trees.treenode.$anonfun$transformup$2(treenode.scala:341)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:183)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:243)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:341)","org.apache.spark.sql.dataset$.$anonfun$ofrows$1(dataset.scala:90)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:88)","org.apache.spark.sql.dataset.(dataset.scala:210)","org.apache.spark.sql.dataset.(dataset.scala:216)","org.apache.spark.sql.dataset.select(dataset.scala:1462)","org.apache.spark.sql.dataset.select(dataset.scala:1517)","org.apache.spark.sql.dataset.withplan(dataset.scala:3715)","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:285)","org.apache.spark.sql.execution.queryexecution.$anonfun$analyzed$1(queryexecution.scala:73)","org.apache.spark.sql.execution.queryexecution.$anonfun$executephase$1(queryexecution.scala:143)","org.apache.spark.sql.execution.queryexecution.analyzed$lzycompute(queryexecution.scala:73)","org.apache.spark.sql.execution.queryexecution.analyzed(queryexecution.scala:71)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:63)","org.apache.spark.sql.execution.queryexecution.executephase(queryexecution.scala:143)","org.apache.spark.sql.functions.sum","org.apache.spark.sql.lowprioritysqlimplicits.newproductencoder$(sqlimplicits.scala:251)","org.apache.spark.sql.lowprioritysqlimplicits.newproductencoder(sqlimplicits.scala:251)","org.apache.spark.sql.sparksession.withactive(sparksession.scala:772)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:32)","os","paramet","parquet","parquet,","partial","partitionfilters:","pass","performance.","physic","plan","plan,","plan.","plan:","polymorph","popular","practic","primit","problem","problem.","problemat","product","product,","project","projections/selections.","provid","pushedfilters:","queri","quick","q|","read","readschema).","readschema:","refer","relation[i#23l,j#24]","releases.","remind","requir","required:","resolv","result","return","root","run","runtim","safe","safe.","safety!","safety.","save","scala","scala.","scala.collection.immutable.list.foreach(list.scala:431)","scala.collection.immutable.list.map(list.scala:293)","scala.collection.immutable.list.map(list.scala:305)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:49)","scala.collection.mutable.resizablearray.foreach$(resizablearray.scala:55)","scala.collection.mutable.resizablearray.foreach(resizablearray.scala:62)","scala.collection.traversablelike.$anonfun$map$1(traversablelike.scala:285)","scala.collection.traversablelike.map$(traversablelike.scala:278)","scala.collection.traversablelike.map(traversablelike.scala:285)","scala.reflect.internal.tpe.typeconstraints$undolog.undo(typeconstraints.scala:73)","scala>","schema","second,","see","select","select()","sense,","separately,","sequenc","serial","serializefromobject","serv","set","shapeless.tag.tagged[string(\"x\")]","show","similarly,","simpl","simplist","slow","small","solut","solv","spark","spark'","spark.","spark.createdataset(","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark:","sparksess","standard","start","statement","statement).","store","string)","string,","string]","struct","subset","such","suffici","suggests,","sum","sum(i)#164l,","support","symbol","syntax","syntax.","take","thing","this.","time","time.","time:","togeth","tri","true,","tutori","two","two.","type","type.","type;","typedaggreg","typedcolumn","typeddataset","typeddataset.","typeddataset.create(ds)","typeddataset.create(seq(mydate(new","unabl","unfortunately,","us","val","valu","value#158l]","value#74l]","veri","view","vs","want","way","well","window","without","work","wrap","w|","x","x:","|","|100|","|value|"],"TypedEncoder.html":["\"daterange\"","\"java.util.date\",","\"s\")","\"s\"))))","\"s\",","(a","(and","(class:","...","//","2.0)","42",":28:",":30:","=","[i:","^","annoy","approach","around","b:","bar","bar(1.1,","bar(d:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","behav","besid","call","care","case","class","class:","classes.","code","compil","construct","coupl","current","custom","data","data.","dataset","dataset?.","dataset[daterange]","daterange(s:","decod","defin","deriv","derived,","detect","different,","double,","ds.collect()","ds:","e:","elid","encod","encoder.","encoder:","encoders,","ensur","error","error:","exampl","example,","exist","expected:","extend","fail","field","find","follow","foo","foo(i:","foodate(i:","found","frameless","frameless.job$$anon$4@77bca0d3","frameless.job[seq[foo]]","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless:","gener","goe","hierarchi","ident","implicit","implicitli","import","inabl","int,","intern","introduc","issues.","java.lang.unsupportedoperationexception:","java.util.d","java.util.date)","java.util.date)))","java.util.date))))","java.util.date)).tods()","java.util.date,","jvm","lead","limit","manipul","mechan","method","more","name:","new","non","note","object","of)","onc","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:56)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$1(scalareflection.scala:562)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$1(scalareflection.scala:591)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$6(scalareflection.scala:577)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfortype$1(scalareflection.scala:421)","org.apache.spark.sql.catalyst.scalareflection$.cleanupreflectionobjects(scalareflection.scala:49)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:432)","org.apache.spark.sql.catalyst.scalareflection$.serializerfortype(scalareflection.scala:413)","org.apache.spark.sql.catalyst.scalareflection.cleanupreflectionobjects$(scalareflection.scala:903)","org.apache.spark.sql.catalyst.scalareflection.cleanupreflectionobjects(scalareflection.scala:904)","org.apache.spark.sql.dataset","org.apache.spark.sql.encoders$.product(encoders.scala:285)","org.apache.spark.sql.lowprioritysqlimplicits.newproductencoder$(sqlimplicits.scala:251)","org.apache.spark.sql.lowprioritysqlimplicits.newproductencoder(sqlimplicits.scala:251)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:32)","overflow","paramet","pass","performance.","prove","question","recurs","reflect","represent","res1:","resolut","root","run","runtim","runtime.","s:","same","scala.collection.immutable.list.map(list.scala:293)","scala.reflect.internal.tpe.typeconstraints$undolog.undo(typeconstraints.scala:73)","scala>","scalareflect","schema.","see","seq(daterange(new","shapeless'","shown","situat","solv","spark","spark'","spark.implicits._","spark:","stack","standard","store","string)","string,","struct]","summari","support","t:","take","through","time,","time.","time:","trace,","tri","type","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeencod","types.","us","val","valu","vanilla","won't","work"],"Injection.html":["$anon$1@17559031","//","1","19","2","2021))","20:29:11","3",":23:",":31:",":35:","=","=>","[age:","^","a):","again","anoth","apply(a:","apply(d:","available,","b","b):","b.","b]","bigint]","birthday:","can't,","case","class","class:","compil","creat","custom","d.gettime()","datetolonginject","datetolonginjection:","def","defin","definit","encod","encoder:","error.","error:","exampl","exhaustive.","extend","fail","family:","femal","female,","find","follow","frameless._","frameless.injection$$anon$1@7c0fbe02","frameless.injection$$anon$1@7d716477","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.typeddataset[person]","frameless.typedencoder[person]","function:","gender","gender)","gender:","gendertoint:","implicit","import","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","inputs:","instanc","int,","int]","invert(b:","invert(l:","jan","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date)","java.util.date))","java.util.date).gettime(),","java.util.date):","java.util.date.","less","let","let'","list(person(42,male))","list(person(42,tu","long","long)))","long):","long:","long]","look","male","male))","male,","match","more","new","now","object","on","paramet","peopl","people:","person","person(age:","persond","personds:","precis","pst","seal","seq(person(42,","seq[person]","serializ","simpl","trait","tri","type","type,","typeclass:","typeddataset,","typeddataset.create(people)","typeddataset:","typedencod","us","val","valu","verbos","warning:","{","}","})","},"],"Job.html":["(a","(sample:","//","1","20%","20)","=","=>","[value:","abil","above)","above,","allow","along","annotate/nam","applic","be","block","calcul","call","captur","cat","cats.effect.sync","collect","compar","complex","compos","composit","comprehens","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","constructor","count","countandtakejob","data","def","default","description.","differ","driver","ds","ds:","easier","effect","effects.","element","elements:","exactli","exampl","example,","execut","expens","explicit","explicitli","f[_]","f[a]","f[a],","few","finaljob","finaljob.","finaljob:","first","frameless.","frameless.job","frameless.job$$anon$2@123416f3","frameless.job[int]","frameless.job[seq[int]])frameless.job[int]","frameless.syntax._","frameless.typeddataset[int]","functions:","further","group","have","help","id","implement","implicitli","import","inform","instanc","instance.","int","int]","issues.","job","job[a]","job[int]","job[seq[int]]):","jobs.","lazi","lazili","lazy,","lazy.","make","mention","min\").","module,","monad","more","new","non","now","obviou","open","oper","order","part","pass","perform","place","predict","program","programm","provid","repres","requir","res2:","result","return","run","run()","sample.map(_.min)","say,","see","sequenc","serv","sever","show","showcas","size","spark","spark.","sparkdelay","sparkdelay[f[_]]","sparksession.","specifi","strict","such","support","suspend","suspens","thunk","toy","track","track,","transform","type","typeclass","typeclass,","typeddataset","typeddataset.create(1","ui","us","user","val","value,","via","withdescription(\"sampl","withgroupid(\"samplingjob\").","{"],"Cats.html":["\"another\")))","\"string\"),","\"task2\"","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(0,0,0)","(1,","(1,2,3)","(10,9,9)","(2,","(8,","(8,2,3)","(and","(chris,map(0","(john,map(0","(sam,map(0","(semigroup)","(seq[(int,","(wrappedarray((1,string)),2)",")","//","1","1)","1))","1)),","1),","1,","10))","10,","100)","11))","12)","12,","15)))","2","2)","2))","2)),","2,","20)","20,","3)","3))","3,","32,","4))","4)),","4,","5,","6,",":43",":45",":46",":49","::","=",">","[_1:","_2:","abil","above.","abstract","action","action[(seq[(int,","action[t]","aggreg","algebra","alia","alias","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","anna","api","arbitrari","arity.","array((joe,map(0","array[(username,","assum","avg,","be","below","block","capabl","captur","case","cat","cats.data.readert","cats.effect.implicits._","cats.effect.io","cats.effect.sync[f].","cats.implicit","cats.implicits._","cats.mtl.implicits._","cats:","class","cmax","cmin","collect","column","combin","common","complex","comput","constructor","conveni","counterpart","csum,","data","data.","data:","dataset","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","deal","default","defin","delay","descript","differ","effect","effect:","effects.","element","empti","empty,","emptyrdd","emptyrdd[13]","enhanc","enrich","etc.","exampl","example,","example:","execut","exist","f[_]","f[_],","first","follow","frameless","frameless.cats.implicits.","frameless.cats.implicits._","frameless.cats.implicits._.","frameless.cats.outer._","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[(int,","frameless:","full","general).","given","group","implicit","implicits.scala:42","implicits.scala:67","import","insid","instanc","int","int)]","int,","integr","io","job,","joe","join","kernel","key","key.","keys.","larg","layer","lazy.","leverag","library:","local","long)","long)]","machineri","main","makerdd","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[23]","mapvalu","max,","meaning","method","min,","modifi","module,","monad","more","mtl","namely,","need","nil","nil)","none","normal","note","noth","now,","offer","on","oper","option","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","outer","over","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","pair","parallelcollectionrdd[12]","parallelcollectionrdd[14]","parallelcollectionrdd[16]","parallelcollectionrdd[18]","parallelcollectionrdd[19]","part","plain","pre","predicates.","previous","println(data.cmax)","println(data.cmaxoption)","println(data.cmin)","println(data.cminoption)","println(data.csum)","println(data.csumoption)","program,","properli","provid","r","rdd","rdd.","rdd:","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","readert","readert[io,","reducebykey","repres","request","res16:","res17:","res19:","res20:","res5:","result","result.run(spark).unsaferunsync()","result:","resultwithdescription:","return","run","run:","same","sampl","sc.emptyrdd","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala.collection.immutable.map[int,int]","scala.collection.immutable.sortedmap","scala.collection.immutable.sortedmap[string,int])]","scala.collection.map[string,scala.collection.immutable.sortedmap[string,int]]","scala.collection.map[user,transactioncount]","section","semigroup","set","show","shuffledrdd[15]","shuffledrdd[17]","simplifi","sort","sortedmap(\"task1\"","sortedmap(\"task3\"","spark","sparkdelay","sparkdelay[f].","sparksess","sparksession,","sparksession.","stack","stack.","stack:","string","string)]","string)],","string]","suppli","suspend","suspended.","suspens","syntax","t]","task","task2","task3","those","thread","timeseri","timeseries)]","togeth","together.","totalperus","totalperuser.collectasmap","totalperuser:","transactioncount","transactioncount)]","tupl","two","type","type.","typeclass","typedd","typeddataset","typeddataset.create(seq((1,","typedds:","us","user","user'","usernam","util","val","valu","variabl","way","work","work,","wrap","yet.","{","|+|"],"TypedML.html":["\"\",","\"lyon\",","\"san","(0","(empti","(name","(repres","(see","(sinc","(the","(what","(which",")","))","...",".as[housedatawithfeatures]","//","0)))","1","1,","1.0","100000)))","100000),","1:","2","2))","2,","2.0","200000),","250000),","2:","3","3)","3.0.0):","3.1.0.","4","500000)","500000),","800000)))","900000)",":)",":37:",":39:",":40:","=",">","[1.0,2.0,3.0]","[_1:","[features:","[squarefeet:","^","_2:","`labels`","`labelsarray`","abov","abstract","accept","add","another,","api","api,","append","array","array(1,","as:","assembl","assembler.transform(testdata).as[housedatawithfeatures]","assembler.transform(trainingdata)","assembler.transform(trainingdata).as[housedatawithfeatures]","assembler.transform(trainingdata).as[wronghousefeatures]","assembler.transform(wrongtrainingdata)","assembler:","back","base","boolean","boolean)","boolean,","boolean:","both","call","calls,","case","case)","cast","categor","check","citi","city.","city:","cityindexed:","class","close","code","column(s)","column(s).","companion","compil","comput","contain","continu","contrari","contribut","correct","current","data","data)","data,","datafram","datawithfeatur","datawithfeatures:","deal","default","defin","depend","deprec","deriv","detail","document","doubl","double)","double,","double]","encod","equival","error:","estimator.","estimators.","exampl","example,","exclus","fact","false,","featur","features(price:","features(squarefeet:","features).","features):","features.","features:","feed","field","field]","fields]","find","fit","footag","footage.","forest,","frameless","frameless._","frameless.ml._","frameless.ml.appendtransformer[rfinputs,frameless.ml.classification.typedrandomforestclassifier.outputs,org.apache.spark.ml.classification.randomforestclassificationmodel]","frameless.ml.appendtransformer[rfinputs,frameless.ml.regression.typedrandomforestregressor.outputs,org.apache.spark.ml.regression.randomforestregressionmodel]","frameless.ml.appendtransformer[stringindexerinput,frameless.ml.feature.typedstringindexer.outputs,org.apache.spark.ml.feature.stringindexermodel]","frameless.ml.classification._","frameless.ml.classification.typedrandomforestclassifier@33ab9b32","frameless.ml.classification.typedrandomforestclassifier[rfinputs]","frameless.ml.feature._","frameless.ml.feature.typedindextostring@355dd92d","frameless.ml.feature.typedindextostring[indextostringinput]","frameless.ml.feature.typedstringindexer@4c2621e0","frameless.ml.feature.typedstringindexer[stringindexerinput]","frameless.ml.feature.typedvectorassembler@a559710","frameless.ml.feature.typedvectorassembler@eb06753","frameless.ml.feature.typedvectorassembler[features]","frameless.ml.regression._","frameless.ml.regression.typedrandomforestregressor@37d61f51","frameless.ml.regression.typedrandomforestregressor[rfinputs]","frameless.ml.typedestimator$$anon$1@5bd75b8","frameless.ml.typedestimator$$anon$1@5d5c3","frameless.ml.typedestimator$$anon$1@6145e82d","frameless.ops.as[(double,","frameless.syntax._","frameless.typeddataset[(string,","frameless.typeddataset[housecityprediction]","frameless.typeddataset[housecitypredictionindexed]","frameless.typeddataset[housecitypredictioninputs]","frameless.typeddataset[housedata]","frameless.typeddataset[housedatawithfeatures]","frameless.typeddataset[housedatawithfeaturesandindex]","frameless.typeddataset[housepriceprediction]","frameless.typeddataset[wronghousedata]","francisco\",","francisco)","from)","garden","hasgarden","hasgarden:","here","hood,","hous","housecitypredict","housecityprediction(","housecitypredictionindex","housecitypredictionindexed(","housecitypredictioninput","housecitypredictioninputs(features:","housedata","housedata(100,","housedata(150,","housedata(20,","housedata(200,","housedata(50,","housedata(squarefeet:","housedata?","housedatawithfeatur","housedatawithfeatures(squarefeet:","housedatawithfeaturesandindex","housedatawithfeaturesandindex(","housepricepredict","housepriceprediction(","i.","ignor","implement","implicit","import","index","indexeddata","indexeddata:","indexedpredict","indexedpredictions:","indexedtestdata","indexedtestdata.project[housecitypredictioninputs]","indexedtestdata:","indexer.estimator.sethandleinvalid(\"keep\")","indexer.estimator.typ","indexer.fit(datawithfeatures).run()","indexer:","indexermodel","indexermodel.transform(datawithfeatures).as[housedatawithfeaturesandindex]","indexermodel.transform(testdatawithfeatures).as[housedatawithfeaturesandindex]","indexermodel:","indextostr","indextostring.transform(indexedpredictions).as[housecityprediction]","indextostring:","indextostringinput","indextostringinput(predictedcityindexed:","input","instanc","instead.","int,","introduc","it.","label","label)","label):","label,","level","leverag","list","locat","lowest","make","matrices.dense(2,","matrix","matrix))","matrix:","matrix]","matrixd","matrixds:","member","method","miss","ml","ml'","model","model.","model.transform(testdata)","model.transform(testdatawithfeatures)","model.transform(testdatawithfeatures).as[housepriceprediction]","model.transform(testinput).as[housecitypredictionindexed]","model:","modul","more","moreover,","name","need","new","not.","now","numer","object.","on","order","org.apache.spark.ml.linalg._","org.apache.spark.ml.linalg.matrix","org.apache.spark.ml.linalg.matrix)]","org.apache.spark.ml.linalg.matrix:","org.apache.spark.ml.linalg.matrixudt.","org.apache.spark.ml.linalg.vector","org.apache.spark.ml.linalg.vector),wronghousefeatures]","org.apache.spark.ml.linalg.vector)]","org.apache.spark.ml.linalg.vectorudt","org.apache.spark.sql.types.userdefinedtype[a]","overview):","paramet","pass","perhap","pleas","possibl","predict","predict).","predictedcity:","predictedcityindexed.","predictedcityindexed:","predictedprice:","predictions.select(predictions.col('predictedcity)).collect.run()","predictions.select(predictions.col('predictedprice)).collect.run()","predictions:","previou","previous","price","price:","probability:","project","prove","provid","random","rawprediction:","remov","repres","res6:","res8:","res9:","return","reus","rf","rf.fit(indexeddata).run()","rf.fit(trainingdatawithfeatures)","rf.fit(trainingdatawithfeatures).run()","rf.fit(wrongtrainingdatawithfeatures)","rf:","rfinput","rfinputs(cityindexed:","rfinputs(price:","rfinputs.","safe","safeti","sale","same","seq[double]","seq[string]","snippet,","spark","spark).","squar","squarefeet:","stay","stridx_267bc5cb88b4","string","string)","string,","stringindexerinput","stringindexerinput(city:","stringindexermodel","strongli","structur","subsequ","take","term","test","testdata","testdata.","testdata:","testdatawithfeatur","testdatawithfeatures:","testinput","testinput:","thank","then,","time","time.","train","trainingdata","trainingdata:","trainingdatawithfeatur","trainingdatawithfeatures:","transform","true,","type","type.","typeddataset","typeddataset'","typeddataset.","typeddataset.create(seq(","typeddataset.create(seq(\"label\"","typeddataset.create(seq(housedata(120,","typeddataset.create(seq(housedata(20,","typeddataset.create(seq(housedata(70,","typeddataset.create(seq(wronghousedata(20,","typeddataset:","typeddatasets.","typedencod","typedencoder[a]","typedestim","typedestimator,","typedestimators,","typedindextostr","typedindextostring[indextostringinput](indexermodel.transformer.labels)","typedrandomforestclassifi","typedrandomforestclassifier.","typedrandomforestclassifier[rfinputs]","typedrandomforestregressor","typedrandomforestregressor.","typedrandomforestregressor[rfinputs]","typedrandomforestregressor[wrongrfinputs]","typedstringindex","typedstringindexer[stringindexerinput]","typedtransform","typedtransformercan","typedvectorassembl","typedvectorassembler[features]","typedvectorassembler[wrongfeatures]","types)","types,","types.","under","us","usual","val","valid","valu","vector","vector)","vector))","vector,","vector:","vector]","vectorassembl","vectorassembler)","vectorassembler.transform(testdata).as[housedatawithfeatures]","vectorassembler.transform(trainingdata).as[housedatawithfeatures]","vectorassembler:","vectord","vectords:","vectors.dense(1,","vectors:","veri","want","warning:","wrappedarray(296250.0)","wrappedarray(san","wrong","wrongfeatur","wrongfeatures(squarefeet:","wronghousedata","wronghousedata(squarefeet:","wronghousedata?","wronghousefeatures(","wrongrfinput","wrongrfinputs(labelofwrongtype:","wrongtrainingdata","wrongtrainingdata:","wrongtrainingdatawithfeatur","wrongtrainingdatawithfeatures:"],"TypedDataFrame.html":["\"dummy\"","\"unique\"","').map(r","'_4)","'q',","'s)","'x',","'z'))","'z'.","(((((((((","(implicit","(phonebooktf:",")",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","//","1.6","1.6+,","1.6,","11","2.10,","2.11","2.11,","22.",":",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","=>","???","addit","address","address,","address:","alphabet:","alternatively,","amount","api","approach","approxim","ariti","avail","away:","b:","bar(i:","bestneighborhood","boolean","boolean)","boolean):","boolean)]","boolean,","both","bring","c:","call","case","catch","caught","caus","citi","citymapentry(","citymaptf:","class","column","columns.","come","common","commonli","compar","compat","compil","complet","comput","concept:","consid","consist","contain","conveni","correct","count:","d:","data","datafram","dataframe,","dataframes,","dataset","def","defin","definit","deprec","design","develop","differ","directli","dive","document.","domain","done","doubl","double,","due","each","earli","element","enough","ensur","essenti","everyth","exampl","example:","except","execut","exist","expect","f","f.neighborhood))","f.residents.split('","fact","family(residents:","field","filter(conditionexpr:","first","flat","focu","follow","foo(s:","frameless","frameless.","frameless.typeddatafram","frameless:","function","further","futur","get","go","goal","goe","handl","have","here","hold","however,","i:","ident","import","improv","inform","instead","int)","int,","interest","intermedi","introduc","introduct","invalid","j:","job","jobs.","join","join1(tf1:","join2(tf1:","joins,","keep","languag","less","let","let'","letter","level","leverag","librari","like,","limit","limitations.","line","long)","long)])","look","main","manag","manipul","manner.","map","mirror","mistak","model","moder","more","much","name","name.exists(set('x',","names,","natur","need","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","neighborhoods:","nlplib","nlplib.uniquename(p.name)","now","number,","object","obtain","ontypeddataframe.","onward.","org.apache.spark.sql.datafram","org.apache.spark.sql.sqlcontext","p","packag","pair","person(name:","person(r,","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","point,","possibl","process","product.","proof","provid","public","readability.","readabl","reasons,","refer","referenc","represent","residents:","result","rethought","return","right","sadly,","safe","safety.","scala","schema","schema.","second","see","see,","seem","select","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","shadow","shapeless.hlist","signatures:","similar","simplifi","singl","spark","spark'","spark,","sqlcontext):","stage","still","store","string","string):","string)]","string)])","string,","suppos","syntax","syntaxes.","system","systems,","tabl","table,","tables:","target","tdataframe[schema","tdataframe[schema]","techniqu","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","time.","track","troubl","tuple23","two","type","type,","type.","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry])","typeddataframe[citymapentry].","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","types:","typo,","uniqu","uniquename(name:","us","user","valu","vanilla","variou","veri","version","way","well,","won't","work","zero.","{","}"]},"length":9},"tokenStore":{"root":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},".":{"0":{"docs":{},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"1":{"3":{"docs":{},".":{"1":{"3":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"docs":{}},"docs":{}}},"docs":{}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"4":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"1":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}}},"5":{"docs":{},".":{"2":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{},"x":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"6":{"docs":{},".":{"1":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{},"x":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"7":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}}},"8":{"docs":{"./":{"ref":"./","tf":0.00684931506849315}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}}},"9":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{},"x":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"docs":{}},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"1":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"i":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}}},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"5":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"9":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.010471204188481676},"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}},".":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}}},"1":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"6":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"+":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"docs":{},"x":{"docs":{"./":{"ref":"./","tf":0.02054794520547945}}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.007853403141361256},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},")":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"docs":{}},"docs":{}},"docs":{}},"2":{"1":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},"docs":{}},"docs":{"./":{"ref":"./","tf":0.00228310502283105}},":":{"2":{"9":{"docs":{},":":{"1":{"1":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"%":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}},"}":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"4":{"0":{"9":{"docs":{},".":{"6":{"3":{"8":{"5":{"5":{"4":{"2":{"1":{"6":{"8":{"6":{"7":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},")":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"{":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"9":{"5":{"5":{"docs":{},".":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005421686746987952},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"1":{"0":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"1":{"docs":{"./":{"ref":"./","tf":0.01141552511415525},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"/":{"2":{"docs":{},".":{"1":{"2":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}},"docs":{}}},"docs":{}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"2":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},".":{"docs":{},"x":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"docs":{}},"2":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}},"1":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}},"docs":{}}},"3":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"1":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"2":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"docs":{}}},"4":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}}},"docs":{}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}}}}}}}}}}}}},"#":{"1":{"6":{"5":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"docs":{}},"docs":{}},"docs":{}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002710843373493976}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}},"}":{"docs":{},"|":{"docs":{},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"{":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"4":{"3":{"6":{"2":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"}":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},".":{"0":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}},")":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"docs":{}}},"1":{"docs":{},".":{"0":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}}},"docs":{}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"4":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"3":{"9":{"1":{"docs":{},".":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"{":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"docs":{}},"docs":{}},"7":{"1":{"5":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"}":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"6":{"8":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"7":{"4":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"8":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"|":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"\"":{"0":{"docs":{},".":{"9":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"docs":{}}},"docs":{}}},"docs":{},"_":{"1":{"docs":{},"\"":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"docs":{}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.00684931506849315}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.00684931506849315}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"b":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"q":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"w":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"y":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"a":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"2":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"docs":{}}}}},"\"":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"%":{"docs":{"./":{"ref":"./","tf":0.00684931506849315}},"%":{"docs":{"./":{"ref":"./","tf":0.00684931506849315}}}},"(":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},",":{"0":{"docs":{},",":{"0":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}}},"docs":{}}},"docs":{}}},"1":{"0":{"docs":{},",":{"9":{"docs":{},",":{"9":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}}},"docs":{}}},"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"2":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"8":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},",":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"y":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"t":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},".":{"docs":{},"e":{"docs":{},".":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"#":{"2":{"3":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738}}}},"docs":{}},"docs":{}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"2":{"3":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.004724409448818898}}}}},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"docs":{}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"1":{"6":{"6":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"e":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"q":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"docs":{}}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"u":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"a":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"\"":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}}}}}},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047}}}}},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"docs":{}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"+":{"1":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.09096385542168675},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.03888419273034658}},"+":{"docs":{},"=":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759}},"/":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.13343373493975905},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.1327134404057481},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.030120481927710843},"Injection.html":{"ref":"Injection.html","tf":0.0755287009063444},"Job.html":{"ref":"Job.html","tf":0.025210084033613446},"Cats.html":{"ref":"Cats.html","tf":0.05235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":0.05826771653543307},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"=":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.02469879518072289},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.011834319526627219},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.024096385542168676},"Injection.html":{"ref":"Injection.html","tf":0.06042296072507553},"Job.html":{"ref":"Job.html","tf":0.029411764705882353},"Cats.html":{"ref":"Cats.html","tf":0.041884816753926704},"TypedML.html":{"ref":"TypedML.html","tf":0.048818897637795275},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0166358595194085}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0084530853761623}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738}}}},">":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Injection.html":{"ref":"Injection.html","tf":0.01812688821752266},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}}},">":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.05235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"=":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}},"p":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}},"e":{"docs":{},"l":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738},"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"g":{"docs":{},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"i":{"docs":{"./":{"ref":"./","tf":0.0091324200913242},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0036144578313253013},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"c":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"d":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"n":{"docs":{},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}},"t":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}},"s":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},".":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},".":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},".":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"3":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"y":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}}},"2":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"(":{"1":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{},"(":{"docs":{},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"docs":{}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"u":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"[":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"4":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},")":{"docs":{},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"o":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"i":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"n":{"docs":{},"o":{"docs":{},"y":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"b":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}},"docs":{}}},"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}},"c":{"docs":{},"k":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"s":{"docs":{},"#":{"1":{"3":{"8":{"7":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"'":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}},"3":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},"\"":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"o":{"docs":{},"w":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.005511811023622047},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}}},"y":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"s":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002710843373493976},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"(":{"1":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"docs":{}},"2":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"docs":{}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0051204819277108436},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.02108433734939759},"Injection.html":{"ref":"Injection.html","tf":0.03927492447129909},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.014960629921259842},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.018484288354898338}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.02054794520547945},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":3.347731239092495}},"s":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"e":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"[":{"docs":{},"f":{"docs":{},"]":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}},"o":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}},"m":{"docs":{},"t":{"docs":{},"l":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}},"r":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}}}}},"o":{"docs":{},"o":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007228915662650603},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0076077768385460695},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03313253012048193},"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.028346456692913385},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.022181146025878003}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"u":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"(":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.010542168674698794},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0076077768385460695},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012939001848428836}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5016906170752327},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0091324200913242},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0076077768385460695},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012048192771084338},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedML.html":{"ref":"TypedML.html","tf":0.004724409448818898},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"x":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}}}}}},"o":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351817621688227}}}}}},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"o":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"o":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.005511811023622047},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"u":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"p":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Injection.html":{"ref":"Injection.html","tf":2.512084592145015}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":2.503021148036254}},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}}}}},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}}}}},"docs":{}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.007874015748031496}}},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"2":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"1":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"3":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"docs":{}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"3":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"4":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.005511811023622047}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"1":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"3":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"4":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012939001848428836}},"e":{"docs":{},"'":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.01598173515981735},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.507607776838546},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"\"":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"/":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"?":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}}}}}}}}}}}}},"y":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014787430683918669}},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0033132530120481927},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.03323262839879154},"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047},"TypedML.html":{"ref":"TypedML.html","tf":0.013385826771653543},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.01598173515981735},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}}}}}},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018072289156626505},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"n":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"'":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0033132530120481927},"TypedML.html":{"ref":"TypedML.html","tf":0.007086614173228346},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedML.html":{"ref":"TypedML.html","tf":0.004724409448818898}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00391566265060241},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.027559055118110236},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"]":{"docs":{},"|":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"(":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"/":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}},"_":{"docs":{},".":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.02108433734939759},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"u":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.007853403141361256}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3544176706827304},"Injection.html":{"ref":"Injection.html","tf":2.512084592145015},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}},"[":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"s":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}}}}},"t":{"docs":{},"i":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004216867469879518},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005917159763313609},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"TypedML.html":{"ref":"TypedML.html","tf":0.004724409448818898}}}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"s":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"i":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}},"_":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}}}}}},"o":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106}}}}}},"h":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},".":{"docs":{},"g":{"docs":{},".":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"[":{"1":{"3":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}},"docs":{}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"i":{"docs":{},",":{"1":{"0":{"docs":{},")":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}},"docs":{}},"docs":{}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"$":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}}}}}}},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.33363453815261},"TypedML.html":{"ref":"TypedML.html","tf":0.010236220472440945}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.009448818897637795}}}}}}}}},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"w":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106}},"e":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0033132530120481927},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.008661417322834646},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00391566265060241},"TypedML.html":{"ref":"TypedML.html","tf":0.007086614173228346}}}}}}},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}}}}}},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005917159763313609},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"c":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.05251141552511415},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002710843373493976},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3423694779116464},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"_":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"_":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}}}}}}}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"?":{"docs":{},"t":{"docs":{},",":{"docs":{},"?":{"docs":{},"c":{"docs":{},"[":{"docs":{},"?":{"docs":{},"a":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"t":{"docs":{},",":{"docs":{},"c":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"c":{"docs":{},"]":{"docs":{},")":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"[":{"docs":{},"t":{"docs":{},",":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},",":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"{":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"=":{"docs":{},">":{"docs":{},"f":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"}":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"d":{"docs":{},"f":{"docs":{},"$":{"docs":{},"$":{"docs":{},"l":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"d":{"docs":{},"a":{"docs":{},"$":{"1":{"2":{"5":{"4":{"9":{"docs":{},"/":{"0":{"docs":{},"x":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"8":{"0":{"3":{"8":{"9":{"8":{"8":{"4":{"0":{"docs":{},"@":{"6":{"1":{"5":{"2":{"1":{"3":{"9":{"7":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"?":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"?":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"t":{"docs":{},"t":{"docs":{},"]":{"docs":{},"{":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},",":{"docs":{},"t":{"docs":{},"t":{"docs":{},"]":{"docs":{},"{":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"2":{"docs":{},"@":{"1":{"2":{"3":{"4":{"1":{"6":{"docs":{},"f":{"3":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"4":{"docs":{},"@":{"7":{"7":{"docs":{},"b":{"docs":{},"c":{"docs":{},"a":{"0":{"docs":{},"d":{"3":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"docs":{}}},"docs":{}}}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},"_":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"7":{"docs":{},"c":{"0":{"docs":{},"f":{"docs":{},"b":{"docs":{},"e":{"0":{"2":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"docs":{}},"docs":{}}}}},"docs":{}},"d":{"7":{"1":{"6":{"4":{"7":{"7":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"@":{"3":{"3":{"docs":{},"a":{"docs":{},"b":{"9":{"docs":{},"b":{"3":{"2":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}},"docs":{}}},"docs":{}}}},"docs":{}},"docs":{}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"@":{"3":{"5":{"5":{"docs":{},"d":{"docs":{},"d":{"9":{"2":{"docs":{},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"@":{"4":{"docs":{},"c":{"2":{"6":{"2":{"1":{"docs":{},"e":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"@":{"docs":{},"a":{"5":{"5":{"9":{"7":{"1":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"e":{"docs":{},"b":{"0":{"6":{"7":{"5":{"3":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"[":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"@":{"3":{"7":{"docs":{},"d":{"6":{"1":{"docs":{},"f":{"5":{"1":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"5":{"docs":{},"b":{"docs":{},"d":{"7":{"5":{"docs":{},"b":{"8":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}}},"docs":{}},"docs":{}}},"d":{"5":{"docs":{},"c":{"3":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}}},"docs":{}}},"6":{"1":{"4":{"5":{"docs":{},"e":{"8":{"2":{"docs":{},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}},"e":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"o":{"docs":{},"m":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0030120481927710845},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"l":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"4":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"f":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},"+":{"2":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"f":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"}":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"[":{"docs":{},"_":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"a":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"l":{"docs":{},")":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015105740181268883}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133}}},"t":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},".":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"8":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}}},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"b":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}},"o":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"a":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"?":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}},"v":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"s":{"docs":{},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.009448818897637795}}}}}}}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"o":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"u":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"s":{"docs":{},"(":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{}},"2":{"0":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"docs":{}},"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}},"?":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"s":{"docs":{},"/":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}},"docs":{}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012048192771084338},"Injection.html":{"ref":"Injection.html","tf":0.015105740181268883},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"l":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"docs":{}},"6":{"7":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"docs":{}},"docs":{}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007228915662650603},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01098901098901099},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.015060240963855422},"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.032722513089005235},"TypedML.html":{"ref":"TypedML.html","tf":0.007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015105740181268883}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Injection.html":{"ref":"Injection.html","tf":2.503021148036254}}},"(":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"n":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"g":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"t":{"docs":{"./":{"ref":"./","tf":10},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253},"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106},"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.007086614173228346}},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"[":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"l":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}},"r":{"docs":{},".":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"f":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}},"t":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}},"o":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},"l":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.015060240963855422}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}}}}}}},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"o":{"docs":{},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Job.html":{"ref":"Job.html","tf":10.004201680672269}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"i":{"docs":{},"n":{"1":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}}}}},"2":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.011090573012939002}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"]":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"v":{"docs":{},"m":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"e":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"s":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}}}}},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0091324200913242}}}}}},"s":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"(":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}},"t":{"docs":{},"u":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}},"f":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"t":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"0":{"1":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}},"docs":{}},"docs":{}}},"1":{"docs":{},".":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"docs":{}}},"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"1":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},",":{"4":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"b":{"docs":{},"c":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"u":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},"o":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"s":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"z":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"y":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"r":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"8":{"2":{"docs":{},".":{"5":{"9":{"7":{"0":{"5":{"4":{"8":{"8":{"6":{"2":{"1":{"1":{"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"m":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"r":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047}}}}}}},"n":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.007853403141361256}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}},"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"docs":{}}}}}},"e":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"2":{"3":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"2":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}}}}}}}}}}},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"l":{"docs":{},"e":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},"x":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}}}}},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"u":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"l":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"TypedML.html":{"ref":"TypedML.html","tf":2.511023622047244}},"\"":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"'":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0091324200913242},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.011811023622047244},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},"e":{"docs":{},"(":{"docs":{},"j":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018072289156626505},"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}},"x":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"t":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"h":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"w":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"l":{"docs":{},"l":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"s":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"v":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}}}}}}}}}},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},"(":{"1":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},",":{"4":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"c":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"Cats.html":{"ref":"Cats.html","tf":0.010471204188481676}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}},"n":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"x":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006762468300929839}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"o":{"docs":{},"f":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.33363453815261}},")":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"$":{"2":{"2":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"5":{"0":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"1":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"4":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"5":{"0":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"7":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"5":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"5":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"8":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"7":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},"$":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"9":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"5":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"$":{"2":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"5":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"1":{"2":{"docs":{},"$":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"5":{"docs":{},"$":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"$":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"5":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"2":{"9":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"7":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"0":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"v":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"2":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"2":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"3":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"1":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"3":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"3":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"4":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"3":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"3":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"3":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"1":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"m":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"1":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"0":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"1":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"2":{"docs":{},"(":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"1":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"0":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"$":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"2":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"4":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"4":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"6":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"9":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"6":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"7":{"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"3":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"1":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"$":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"0":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"0":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"$":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"4":{"6":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"5":{"1":{"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"7":{"1":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"1":{"0":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},".":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"$":{"docs":{},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"4":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"$":{"docs":{},"l":{"docs":{},"z":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"4":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"$":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"{":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"7":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"5":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"5":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"{":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},".":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"g":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},")":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"u":{"docs":{},"d":{"docs":{},"t":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},")":{"docs":{},",":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"u":{"docs":{},"d":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"8":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"b":{"docs":{},"j":{"docs":{},"#":{"7":{"2":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"3":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253},"Injection.html":{"ref":"Injection.html","tf":0.01812688821752266},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"l":{"docs":{},"y":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.011811023622047244}},")":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0091324200913242},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351817621688227}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}},"l":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedML.html":{"ref":"TypedML.html","tf":0.004724409448818898}},"#":{"1":{"3":{"8":{"6":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"/":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.007086614173228346}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"b":{"docs":{},"y":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"3":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"2":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"4":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"6":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"8":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"9":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"i":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01014370245139476}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"i":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133}},"(":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.01812688821752266}},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}},"i":{"docs":{},"v":{"docs":{},"o":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"t":{"docs":{},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"c":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"s":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"d":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"Cats.html":{"ref":"Cats.html","tf":3.338568935427574}},"s":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"#":{"2":{"3":{"docs":{},"l":{"docs":{},",":{"docs":{},"j":{"docs":{},"#":{"2":{"4":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"i":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}},"a":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"[":{"docs":{},"i":{"docs":{},"o":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"u":{"docs":{},"i":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"s":{"1":{"6":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"7":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"9":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"2":{"0":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"3":{"0":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"4":{"5":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"5":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"6":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"8":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"9":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"u":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002710843373493976},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"u":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"e":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004216867469879518}}},"o":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"f":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"m":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}}},"p":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"y":{"docs":{},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"l":{"docs":{},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"d":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0091324200913242}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"3":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"3":{"0":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"$":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"$":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"[":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"w":{"docs":{},",":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},".":{"docs":{},"t":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"$":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},">":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},".":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0033132530120481927},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"[":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.012605042016806723}}}}}}},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"i":{"docs":{},"z":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"'":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004216867469879518},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"(":{"1":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"5":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"7":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}},"docs":{}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"y":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002710843373493976},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"z":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.02511415525114155},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01014370245139476},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Job.html":{"ref":"Job.html","tf":0.03361344537815126},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":2.5078740157480315},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.018484288354898338}},"'":{"docs":{"./":{"ref":"./","tf":0.0091324200913242},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5050718512256975},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},")":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},".":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"[":{"docs":{},"*":{"docs":{},"]":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"_":{"2":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"docs":{}}}}},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"[":{"docs":{},"f":{"docs":{},"[":{"docs":{},"_":{"docs":{},"]":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"]":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"y":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"g":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.007086614173228346},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},",":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.01144578313253012},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.004724409448818898},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014787430683918669}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"d":{"docs":{},"x":{"docs":{},"_":{"2":{"6":{"7":{"docs":{},"b":{"docs":{},"c":{"5":{"docs":{},"c":{"docs":{},"b":{"8":{"8":{"docs":{},"b":{"4":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}}},"docs":{}},"docs":{}}}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"l":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"q":{"docs":{},"u":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},"#":{"1":{"6":{"4":{"docs":{},"l":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"docs":{}},"docs":{}},"docs":{}}}}},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"#":{"1":{"3":{"8":{"5":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00391566265060241}}},"]":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"1":{"0":{"docs":{},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}},"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}}},"3":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}},"n":{"docs":{},"i":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}}}}}}}}}}},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"t":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"_":{"2":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"s":{"docs":{},"k":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.005511811023622047}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"l":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"r":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}},"n":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"a":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"u":{"docs":{},"n":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"2":{"3":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"docs":{}},"docs":{}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},"a":{"docs":{},"l":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.01598173515981735},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008734939759036145},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.014370245139475908},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3453815261044175},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.02356020942408377},"TypedML.html":{"ref":"TypedML.html","tf":0.015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.027726432532347505}},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.344423906346272}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"p":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0091324200913242},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0033132530120481927},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.503381234150465},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":2.5039370078740157}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}},"docs":{}}}}}}}}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}},"\"":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"1":{"2":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{}},"2":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"7":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"2":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.01812688821752266}}}}}}}}}}}}}}}}},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3342369477911644},"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},"a":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{},"]":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{},"n":{"docs":{},"[":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"u":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}}}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"'":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"s":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"s":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"s":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"a":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012048192771084338}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00391566265060241}},"i":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133}}},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.008661417322834646}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"w":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}},"f":{"1":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"j":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"2":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"j":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}},"t":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"p":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{"./":{"ref":"./","tf":0.01598173515981735},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008132530120481927},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"Cats.html":{"ref":"Cats.html","tf":3.3424956369982546},"TypedML.html":{"ref":"TypedML.html","tf":2.5118110236220472},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.009242144177449169}},"a":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"'":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"d":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.011746987951807229},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018072289156626505},"Injection.html":{"ref":"Injection.html","tf":0.03323262839879154},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.015706806282722512},"TypedML.html":{"ref":"TypedML.html","tf":0.023622047244094488}},"u":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047},"TypedML.html":{"ref":"TypedML.html","tf":0.006299212598425197},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"#":{"1":{"5":{"8":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"docs":{}},"docs":{}},"7":{"4":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"docs":{}},"docs":{}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"o":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.01598173515981735},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.006299212598425197}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.009448818897637795}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"a":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0030120481927710845},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}}}},"y":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"h":{"docs":{},"y":{"docs":{},"?":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}},"docs":{}}}}}}}}}}}},"/":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"]":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004216867469879518},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}},"]":{"docs":{},"(":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"2":{"9":{"6":{"2":{"5":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"(":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}},"docs":{}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}},"?":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"s":{"docs":{},"(":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"f":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"}":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"w":{"docs":{},",":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"$":{"docs":{},"\"":{"docs":{},"*":{"docs":{},"\"":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"i":{"docs":{},"\"":{"docs":{},"*":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"1":{"4":{"docs":{},".":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"1":{"7":{"5":{"5":{"9":{"0":{"3":{"1":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}},"'":{"docs":{},"`":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}},"x":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"`":{"docs":{},"i":{"docs":{},"`":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"_":{"4":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}},"q":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"z":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"*":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0036144578313253013},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},"(":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0084530853761623}}}},"docs":{}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0051204819277108436},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.014173228346456693}},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"*":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"'":{"docs":{},"_":{"2":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"_":{"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"docs":{}}}}}}},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"2":{"0":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"3":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"5":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"9":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}},"docs":{}},"3":{"0":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"1":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"5":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}},"7":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}}}},"9":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"4":{"0":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"5":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"6":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"9":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Cats.html":{"ref":"Cats.html","tf":0.02356020942408377}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"[":{"1":{"docs":{},".":{"0":{"docs":{},",":{"2":{"docs":{},".":{"0":{"docs":{},",":{"3":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{},".":{"docs":{},".":{"1":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"docs":{}},"docs":{}}}}},"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"x":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"_":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0036144578313253013},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"docs":{}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"#":{"1":{"3":{"8":{"4":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004819277108433735}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"]":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"t":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115}}}},"a":{"docs":{},"]":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}},"i":{"docs":{},"#":{"2":{"3":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},",":{"docs":{},"j":{"docs":{},"#":{"2":{"4":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"[":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}}}}}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"2":{"3":{"docs":{},"l":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}},"docs":{}},"docs":{}},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"2":{"3":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"docs":{}},"docs":{}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.010236220472440945}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}}}}}}}}},"^":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004216867469879518},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133},"TypedML.html":{"ref":"TypedML.html","tf":0.005511811023622047}}},"_":{"1":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00391566265060241}}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0036144578313253013},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00391566265060241}}}},"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}},"4":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"{":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.015105740181268883},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"|":{"1":{"0":{"0":{"0":{"docs":{},"|":{"1":{"0":{"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"2":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"7":{"6":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"6":{"2":{"docs":{},".":{"8":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"9":{"0":{"8":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"1":{"2":{"docs":{},".":{"5":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"8":{"docs":{},"|":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.01566265060240964},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006762468300929839}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"|":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}}}}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"|":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0030120481927710845}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"b":{"docs":{},"c":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"{":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}},"+":{"docs":{},"|":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}}}},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"`":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},"`":{"docs":{},")":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"`":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"`":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}},"y":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"?":{"docs":{},"?":{"docs":{},"?":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"length":3641},"corpusTokens":["\"\",","\"0.9.0\"","\"_1\".","\"a","\"abc\")","\"another\")))","\"daterange\"","\"dummy\"","\"e\")","\"false\")","\"frameless","\"java.util.date\",","\"jday\")","\"lyon\",","\"mydate\"","\"org.typelevel\"","\"paris\")","\"paris\",","\"q\")","\"s\")","\"s\"))))","\"s\",","\"san","\"string\"),","\"task2\"","\"unique\"","\"value\"","\"w\")","$\"*\".","$\"i\"*2)","$anon$1@17559031","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","%","%%","'(sum(`i`)","').map(r","'_4)","'`citi`'","'`i`'","'`x`'","'city),","'name),","'null'","'population)","'price),","'project","'q',","'s)","'x',","'z'))","'z'.","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(((((((((","(0","(0,0,0)","(1,","(1,2,3)","(10,9,9)","(2,","(8,","(8,2,3)","(a","(and","(apttypedds)","(apttypedds2)","(case","(chris,map(0","(class:","(column:","(e.g.","(e.g.,","(empti","(enjoy","(frameless.typedcolumn[(string,","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(from","(i","(i#23l","(i.e.,","(if","(implicit","(in","(includ","(int)","(int,","(isnotnull(i#23l)","(john,map(0","(look","(lyon,166500.0))","(name","(name:","(or","(paris,333333.3333333333),","(peopl","(phonebooktf:","(repres","(sam,map(0","(sample:","(see","(semigroup)","(seq[(int,","(short","(sinc","(string,","(such","(the","(thumb","(u:","(up","(what","(which","(with","(wrappedarray((1,string)),2)",")","))",").as[apartmentdetails]",").as[aptpricecity].show().run",").as[stats].show().run()",").show().run()",").show(1).run()",").show(2).run()","*","*(1)","+","++=","+1,",",","...","...).",".ac",".appli",".as[family]()",".as[housedatawithfeatures]",".as[neighborhoodcount]()",".dataset",".desc.",".filter",".flatmap",".flattenopt",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select($\"*\",",".select('_2,",".select('neighborhood)",".sortdesc('count)","/","//","0","0)))","0.0|","0.0|325000.0|","0.13.13:","0.2,","0.4","0.4.0","0.4.1","0.5.2","0.5.x","0.6.1","0.6.x","0.7.0","0.8","0.8.0","0.9","0.9.0","0.9.x","1","1)","1))","1)),","1),","1,","1.0","1.0.0","1.1|","1.6","1.6+,","1.6,","1.x","10","10))","10),","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10).select(fds('i)).explain()","10).select(fds('i)).show().run()","10).select(fds('x))","10)],","10,","100)","100,","10000.0,","100000)))","100000),","102|","10|","11","11))","12)","12,","133000...|","133000.0,","133000.0|","133|","15)))","19","1:","1|","1|250000.0|","2","2)","2)#165l]","2))","2)),","2)).","2)).show().run()","2),","2).as[updatedsurface]","2).show().run()","2).show(2).run()","2,","2.0","2.0)","2.0,","2.10,","2.11","2.11,","2.11/2.12","2.12","2.12.x.","2.2.0","2.2.1","2.3.0","2.3.0.","2.3.1","2.3.2.","2.4.0","20","20%","20)","20,","200000),","200000...|","200000.0,","200000.0|","2021))","20:29:11","22.","2229621),","2229621|","2229621}|","2409.6385542168673,","25,","25000...|{paris,","250000),","250000.0,","250000.0|","250|","25|[paris,","27|","2955.5555555555557,","2:","2|","2|300000.0|","2|[a,","2}|[a,","3","3)","3))","3),","3,","3.0.0","3.0.0):","3.1.0.","30000...|{paris,","300000.0,","300000.0|","32,","325000...|","325000.0,","325000.0|","343629)","343629|","343629}|","3|","3|450000.0|","3|[a,","4","4))","4)),","4,","42","4391.891891891892)","4391.891891891892|","45,","4500...|{paris,","4500.0,","450000.0,","450000.0|","450|","45|133000.0|","47|","4|","5,","50,","500000)","500000),","500715),","500715|","500715}|","500|","50|300000.0|","52|","6,","6833.333333333333|","74,","740|","76|","800000)))","83,","830|","83|200000.0|","85|","9000.0|","900000)",":",":)",":20:",":23:",":24:",":25:",":26:",":27:",":28:",":29:",":30:",":31:",":35:",":36:",":37:",":39:",":40:",":43",":45",":46",":49","::",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","==","===","=>",">",">=","???","['citi]","['x]","[1...10]).","[1.0,2.0,3.0]","[],","[_1:","[a]frameless.typedcolumn[foo,a]","[age:","[bedrooms,","[city#1384,","[city:","[features:","[i#23l","[i#23l,j#24]","[i#23l]","[i,","[i:","[input[0,","[isnotnull(i#23l),","[isnotnull(i),","[out,","[out]frameless.typedaggregate[foo,out]","[ratio:","[squarefeet:","[sum(i#23l)","[tt,","[value:","^","_1.","_1|","_2:","_2|","_3|","_4|","`labels`","`labelsarray`","`sum(i)`)'","a)(implicit","a):","a,","ab","abil","abov","above)","above,","above.","abstract","accept","access","accident","achiev","act","action","action[(seq[(int,","action[t]","actual","ad","adapt","add","added,","addit","addition,","address","address,","address:","adelbertc","adjust","adjustedpric","adjustedprice.show().run()","adjustedprice:","advanc","aforement","again","against","agg()","agg(avg(aptds('price))).","aggreg","aggregated,","agree.","algebra","alia","alias","align","align.","allcities:","allcities|","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","allowed,","allowed:","along","alphabet:","alternatively,","alternatives:","amount","and/or","anna","annotate/nam","annoy","anoth","another,","anyth","apach","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartment.","apartmentdetail","apartmentdetails(city:","apartmentdetails?","apartmentopt(city:","apartmentopt(none,","apartmentopt(some(\"paris\"),","apartmentshortinfo","apartmentshortinfo(city:","apartmentshortinfo?","apartmentsopt","api","api,","api.","apis),","appear","append","appli","applic","applications.","apply(a:","apply(d:","approach","approach,","approxim","aptd","aptds('city),","aptds('price)","aptds('price)))","aptds('price),","aptds('surface),","aptds('surface).cast[double]","aptds('surface).cast[double])","aptds.","aptds.agg(","aptds.select(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)","apttypedds('city)).as[updatedsurface]","apttypedds('city).asc,","apttypedds('city).cast[double]","apttypedds('price).desc","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.joininner(citiinfotypedds)","apttypedds.makeudf(pricemodifier)","apttypedds.orderby(","apttypedds.orderby(apttypedds('city).asc).show(2).run()","apttypedds.project[apartmentshortinfo]","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds.union(apttypedds2).show().run","apttypedds2","apttypedds2('price)","apttypedds2('price)).","apttypedds2.drop[citybeds]","apttypedds2.droptupled('price):","apttypedds2.union(apttypedds).show().run","apttypedds2.withcolumnreplaced('price,","apttypedds2.withcolumntupled(","apttypedds2.withcolumntupled(lit(array(\"a\",\"b\",\"c\"))).show(2).run()","apttypedds2:","apttypedds:","apttypeddsopt","apttypeddsopt('surface)","apttypeddsopt('surface).opt.map(_","apttypeddsopt.select(apttypeddsopt('surface)","apttypeddsopt.select(apttypeddsopt('surface).opt.map(c","apttypeddsopt.show().run()","apttypeddsopt:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","are:","area","argument","arguments)","arithmet","ariti","arity.","around","array","array((joe,map(0","array(1,","array[(username,","array]","arraycontains(t('_1),","arraycontains(t('_2),","arraycontains:","as:","as[bedroomstats]","as[long]","as[t]","ascol","ascol()","assembl","assembler.transform(testdata).as[housedatawithfeatures]","assembler.transform(trainingdata)","assembler.transform(trainingdata).as[housedatawithfeatures]","assembler.transform(trainingdata).as[wronghousefeatures]","assembler.transform(wrongtrainingdata)","assembler:","associ","assum","automat","avail","available,","available.","averag","averaging,","avg","avg(aptds('price))","avg(aptds('price)),","avg(aptds('surface))","avg(aptds('surface)),","avg,","avgprice:","avgpricebeds1:","avgpricebeds2:","avgpricebeds3:","avgpricebeds4:","avgprice|","avgsurface:","avgsurface|minsurface|","avoid","away:","b","b):","b,","b.","b:","b]","back","bar","bar(1)))","bar(1.1,","bar(d:","bar(i:","bar)","bar.","bardate(1.1,","bardate(d:","bardate)","base","batched:","be","becom","bedroom","bedrooms#1387]","bedrooms.","bedrooms:","bedroomstat","bedroomstats(","bedroomstats('avgpricebeds2).getorelse(0.0),","bedroomstats('avgpricebeds3).getorelse(0.0))","bedroomstats(lyon,some(133000.0),some(200000.0),none,none)","bedroomstats(nice,none,none,some(325000.0),none)","bedroomstats(paris,some(250000.0),some(300000.0),some(450000.0),none)","bedroomstats.collect().run().foreach(println)","bedroomstats.dataset.todf().filter($\"avgpricebeds2\".isnotnull)","bedroomstats.flattenoption('avgpricebeds2)","bedroomstats.select(","bedroomstats.show().run()","bedroomstats:","before.","behav","behavior","bellow:","below","below.","benefit","besid","best","bestneighborhood","better","between","bigint","bigint))","bigint,","bigint]","bind","birthday:","block","boolean","boolean)","boolean):","boolean)]","boolean)].","boolean,","boolean:","bootstrap","both","break","bring","bug","build.sbt","built","bulletproof:","bypass","c","c('_2)).show(2).run()","c,","c.","c.select(c.colmany('_1,","c.show(1).run()","c:","c]|","calcul","call","caller","calls,","can't","can't,","capabl","captur","care","case","case)","case,","cases.","cast","cast(10","cast(2","cast,","cat","catalyst","catalystcast.","catalystcast[string,","catch","categor","cats\"","cats.","cats.data.readert","cats.effect.implicits._","cats.effect.io","cats.effect.sync","cats.effect.sync[f].","cats.implicit","cats.implicits._","cats.mtl.implicits._","cats:","caught","caus","chang","change.","channel","check","choos","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name)","city,","city.","city:","cityb","citybeds(city:","citybeds(lyon,2))","citybeds(paris,1))","citybeds(paris,1),","citybeds(paris,3))","citybeds(paris,3),","citybeds.","citybeds.head(3).run()","citybeds.headoption.run()","citybeds.limit(4).collect().run()","citybeds.select(citybeds.ascol,","citybeds.take(2).run()","citybeds:","citybedsoth","citybedsother(city:","cityindexed:","cityinfo","cityinfo(city:","citymapentry(","citymaptf:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.select(cityratio('city),","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|avgpricebeds1|avgpricebeds2|avgpricebeds3|avgpricebeds4|","city|bedrooms|","city|surface|","class","class:","classes)","classes.","claus","clause.","clearli","click","close","closur","closures.","cmax","cmin","code","code.","collect","collect())","collection,","collectset(aptds('city))","colmany()","column","column\")","column(s)","column(s).","column,","column.","column:","columnar","columnartorow","columns)","columns,","columns.","columns:","combin","come","common","commonli","companion","compar","comparison","comparison,","compat","compil","compile)","compile,","compile.","compile:","compiles:","complet","complex","compos","composit","comprehens","compromis","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","concat,","concept:","condition","conduct","conf","confus","consid","consist","consol","construct","constructor","contain","content","context","continu","contrari","contribut","contributor","conveni","convention.","convert","correct","correct.","correctli","correspond","count","count,","count:","countandtakejob","counterpart","coupl","creat","csum,","current","custom","customizable,","d.gettime()","d:","d]|true|","data","data)","data,","data.","data:","datafilters:","datafram","dataframe'","dataframe,","dataframes,","dataset","dataset\"","dataset,","dataset.","dataset/datafram","dataset:","dataset?.","dataset[daterange]","dataset[long].","datasets,","datawithfeatur","datawithfeatures:","daterange(s:","datetolonginject","datetolonginjection:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","deal","decod","def","default","defin","definit","delay","depend","deprec","deriv","derived,","descript","description.","deserializetoobject","design","design,","detail","detail.","detect","develop","differ","different,","directli","discuss","discussion.","disk","distinguish","dive","divid","divided,","document","document.","domain","don't","done","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","drop","drop().","drop/replace/add","droptupled()","ds","ds.collect()","ds.filter($\"i\"","ds.filter(_.i","ds.select(sum($\"i\"),","ds.show()","ds:","due","e.g.,","e:","each","earli","easi","easier","easili","effect","effect,","effect:","effects.","element","elements.","elements:","elid","empti","empty,","emptyrdd","emptyrdd[13]","encod","encoder,","encoder.","encoder:","encoder[bar]","encoders,","enhanc","enough","enrich","ensur","entir","environ","equalto(i,10)],","equival","equivelantli","error","error)","error.","error:","essenti","estimator.","estimators.","etc)","etc.","etc.).","everyth","evid","evidence$1:","exactli","exampl","example,","example.","example:","except","exclus","execut","exhaustive.","exist","expect","expected:","expens","explain","explan","explicit","explicitli","explode()","explode(_2)","explode(_2),","expos","express","expression'","expressionencod","extend","extra","extrem","e|","f","f.neighborhood))","f.residents.split('","f[_]","f[_],","f[a]","f[a],","fact","fail","failure:","false,","false]","familiar","family(residents:","family:","faster","fd","fds('i)).show().run()","fds.agg(fsum(fds('i))+22).show().run()","fds.agg(fsum(fds('i)),","fds.filter(fds('i)","fds.select(fsum(fds('i)))","fds:","featur","features(price:","features(squarefeet:","features).","features):","features.","features:","feed","feel","femal","female,","few","field","field]","fields.","fields]","file","file.","filescan","filter","filter(conditionexpr:","filteredd","filteredds.explain()","filteredds.show()","filteredds:","finaljob","finaljob.","finaljob:","finally,","find","first","first()","first,","first_value)","fit","five","flat","flatten","flattened.show(4).run()","flattened:","flattenstat","flattenstats:","focu","follow","follows:","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo(s:","foo,","foo.","foodate(i:","footag","footage.","forest,","form","formal","format","format:","found","frameless","frameless'","frameless,","frameless.","frameless._","frameless.abstracttypedcolumn[?t,?c[?a]]","frameless.abstracttypedcolumn[t,c[a]]","frameless.abstracttypedcolumn[t,c[a]],","frameless.catalystcast[string,double]","frameless.catalystcollection[c])column.thistype[t,boolean]","frameless.catalystdivisible[double,out],","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.catalystnumeric[option[int]])frameless.typedcolumn[apartmentopt,option[int]]","frameless.catalystnumeric[option[int]],","frameless.cats.implicits.","frameless.cats.implicits._","frameless.cats.implicits._.","frameless.cats.outer._","frameless.functions._","frameless.functions.aggregate._","frameless.functions.aggregate.{sum","frameless.functions.aggregate.{sum=>fsum}","frameless.functions.lit","frameless.functions.nonaggregate._","frameless.functions.nonaggregate.when","frameless.functions.udf$$lambda$12549/0x0000000803898840@61521397","frameless.injection$$anon$1@7c0fbe02","frameless.injection$$anon$1@7d716477","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.job","frameless.job$$anon$2@123416f3","frameless.job$$anon$4@77bca0d3","frameless.job[int]","frameless.job[seq[foo]]","frameless.job[seq[int]])frameless.job[int]","frameless.ml._","frameless.ml.appendtransformer[rfinputs,frameless.ml.classification.typedrandomforestclassifier.outputs,org.apache.spark.ml.classification.randomforestclassificationmodel]","frameless.ml.appendtransformer[rfinputs,frameless.ml.regression.typedrandomforestregressor.outputs,org.apache.spark.ml.regression.randomforestregressionmodel]","frameless.ml.appendtransformer[stringindexerinput,frameless.ml.feature.typedstringindexer.outputs,org.apache.spark.ml.feature.stringindexermodel]","frameless.ml.classification._","frameless.ml.classification.typedrandomforestclassifier@33ab9b32","frameless.ml.classification.typedrandomforestclassifier[rfinputs]","frameless.ml.feature._","frameless.ml.feature.typedindextostring@355dd92d","frameless.ml.feature.typedindextostring[indextostringinput]","frameless.ml.feature.typedstringindexer@4c2621e0","frameless.ml.feature.typedstringindexer[stringindexerinput]","frameless.ml.feature.typedvectorassembler@a559710","frameless.ml.feature.typedvectorassembler@eb06753","frameless.ml.feature.typedvectorassembler[features]","frameless.ml.regression._","frameless.ml.regression.typedrandomforestregressor@37d61f51","frameless.ml.regression.typedrandomforestregressor[rfinputs]","frameless.ml.typedestimator$$anon$1@5bd75b8","frameless.ml.typedestimator$$anon$1@5d5c3","frameless.ml.typedestimator$$anon$1@6145e82d","frameless.ops.as[(double,","frameless.ops.as[(string,","frameless.syntax._","frameless.typedaggregate[foo,?]","frameless.typedcolumn[(string,","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[foo,?]","frameless.typedcolumn[tt,double])(implicit","frameless.typedcolumn[tt,option[int]])(implicit","frameless.typeddatafram","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(citybeds,","frameless.typeddataset[(double,","frameless.typeddataset[(int,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[apartmentopt]","frameless.typeddataset[apartmentshortinfo]","frameless.typeddataset[bedroomstats]","frameless.typeddataset[citybeds]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[foo]","frameless.typeddataset[housecityprediction]","frameless.typeddataset[housecitypredictionindexed]","frameless.typeddataset[housecitypredictioninputs]","frameless.typeddataset[housedata]","frameless.typeddataset[housedatawithfeatures]","frameless.typeddataset[housedatawithfeaturesandindex]","frameless.typeddataset[housepriceprediction]","frameless.typeddataset[int]","frameless.typeddataset[person]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[this.out]","frameless.typeddataset[updatedsurface]","frameless.typeddataset[wronghousedata]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless.typedencoder[mydate]","frameless.typedencoder[out],","frameless.typedencoder[person]","frameless.with[apartment,tt]{typ","frameless.with[apartmentopt,tt]{typ","frameless:","frameless_gen_min_s","frameless_gen_size_rang","framelessvers","framelessversion,","francisco\",","francisco)","free","friend.","friendli","from)","fsum}","full","fulli","function","function(s)","function.","function:","functions.","functions:","further","futur","g8","garden","gender","gender)","gender:","gendertoint:","gener","general).","generated.","get","get.;","getorelse().","giter8","github,","gitter","gitter)","give","given","go","goal","goal:","goe","great!","ground,","group","groupbi","groupby()","groupby(aptds('city)).","guard","hand","handhold","handl","harder","hasgarden","hasgarden:","have","help","help?","here","here.","here:","hierarchi","hold","hood,","hous","housecitypredict","housecityprediction(","housecitypredictionindex","housecitypredictionindexed(","housecitypredictioninput","housecitypredictioninputs(features:","housedata","housedata(100,","housedata(150,","housedata(20,","housedata(200,","housedata(50,","housedata(squarefeet:","housedata?","housedatawithfeatur","housedatawithfeatures(squarefeet:","housedatawithfeaturesandindex","housedatawithfeaturesandindex(","housepricepredict","housepriceprediction(","however,","http://opensource.org/licenses/apach","i.","i:","id","ident","if(nam","ignor","imario","imarios/frameless.g8","imperfections,","implement","implicit","implicitli","implicits.scala:42","implicits.scala:67","import","improv","inabl","includ","incompat","index","indexeddata","indexeddata:","indexedpredict","indexedpredictions:","indexedtestdata","indexedtestdata.project[housecitypredictioninputs]","indexedtestdata:","indexer.estimator.sethandleinvalid(\"keep\")","indexer.estimator.typ","indexer.fit(datawithfeatures).run()","indexer:","indexermodel","indexermodel.transform(datawithfeatures).as[housedatawithfeaturesandindex]","indexermodel.transform(testdatawithfeatures).as[housedatawithfeaturesandindex]","indexermodel:","indextostr","indextostring.transform(indexedpredictions).as[housecityprediction]","indextostring:","indextostringinput","indextostringinput(predictedcityindexed:","inflat","inflation.show(2).run()","inflation:","inform","initi","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","inmemoryfileindex[file:/tmp/foo],","input","inputs:","insid","instal","instanc","instance,","instance.","instances:","instanti","instead","instead.","int","int)","int).","int)]","int,","int.","int]","integr","intention","interest","intermedi","intern","introduc","introduct","intuitively,","invalid","invert(b:","invert(l:","io","issue,","issue:","issues.","issues/questions.","it'","it.","i|","j.","j:","j];","jan","jar.","java.lang.unsupportedoperationexception:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date(system.currenttimemillis))))","java.util.date)","java.util.date))","java.util.date)))","java.util.date))))","java.util.date)).tods()","java.util.date).gettime(),","java.util.date):","java.util.date,","java.util.date.","job","job,","job[a]","job[int]","job[seq[int]]):","jobs.","joe","join","join1(tf1:","join2(tf1:","joins,","jvm","j|","kanterov","keep","kernel","key","key.","keys.","know","known","label","label)","label):","label,","languag","larg","last","later","layer","lazi","lazili","lazy,","lazy.","lead","learning.","less","let","let'","letter","level","leverag","librari","library:","librarydepend","licens","lift","like,","limit","limitations.","line","linux","list","list(","list(person(42,male))","list(person(42,tu","list[int])]","list[string])","list[string]),string]","list[string]),string],","list[string])]","lit(0.001))","lit(1.1)).","lit(list(\"a\",\"b\",\"c\")))","lit(list(\"abc\",\"c\",\"d\")))","lit(list(1,2,3,4)))","litaggr(\"hello","liter","load","local","localrel","locat","location:","long","long)","long)))","long):","long)]","long)])","long,","long:","long]","look","lose","lowest","lyon]|","lyon|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","mac","machineri","macro","made","main","maintain","make","makerdd","male","male))","male,","manag","mani","manipul","manner.","map","map()","map(0","map(1","map(bob","map(task1","map[int,int]","mapel","mappartitionsrdd[23]","mapvalu","match","materialize.","math","matrices.dense(2,","matrix","matrix))","matrix:","matrix]","matrixd","matrixds:","matter","max,","meaning","mechan","member","members.","mention","merg","messag","method","method.","min\").","min(aptds('surface)),","min(aptds('surface)).cast[double],","min,","minim","minimum","minsurface:","mirror","mismatch;","miss","missing,","misspel","mistak","mix","ml","ml\"","ml'","model","model.","model.transform(testdata)","model.transform(testdatawithfeatures)","model.transform(testdatawithfeatures).as[housepriceprediction]","model.transform(testinput).as[housecitypredictionindexed]","model:","moder","modifi","modul","module,","modules:","monad","more","moreover,","mtl","much","multipl","mydat","mydate(jday:","n","n:","name","name.exists(set('x',","name:","namely,","names,","names/typ","names/types,","natur","need","needed:","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","neighborhoods:","nest","new","newinstance(class","next","next,","nice,","nice|","nice|325000.0|","nil","nil)","nlplib","nlplib.uniquename(p.name)","non","none","none),","none).","none,","normal","not,","not.","note","noth","notifi","now","now,","null).","null|","null|450000.0|","number","number,","numer","obj#72:","obj#73:","object","object.","obtain","obviou","of)","offer","offici","often,","ok","olivierblanvillain","on","on(1,2,3,4).","onc","ontypeddataframe.","onward.","open","oper","operation.","operations,","operations:","opt","optim","optimizer)","option","option.","option[citybeds]","option[double]","option[double])","option[double])]","option[double],","option[int])","option[int])(implicit","option[int],","option[string],","option[x]","options.","order","order.","org.apache.spark.ml.linalg._","org.apache.spark.ml.linalg.matrix","org.apache.spark.ml.linalg.matrix)]","org.apache.spark.ml.linalg.matrix:","org.apache.spark.ml.linalg.matrixudt.","org.apache.spark.ml.linalg.vector","org.apache.spark.ml.linalg.vector),wronghousefeatures]","org.apache.spark.ml.linalg.vector)]","org.apache.spark.ml.linalg.vectorudt","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","org.apache.spark.sql,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$$anonfun$apply$22.applyorelse(analyzer.scala:2503)","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$$anonfun$apply$22.applyorelse(analyzer.scala:2510)","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$.apply(analyzer.scala:2447)","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$.apply(analyzer.scala:2503)","org.apache.spark.sql.catalyst.analysis.analyzer.$anonfun$executeandcheck$1(analyzer.scala:173)","org.apache.spark.sql.catalyst.analysis.analyzer.$anonfun$executeandcheck$1(analyzer.scala:175)","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.analyzer.execute(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.analyzer.execute(analyzer.scala:189)","org.apache.spark.sql.catalyst.analysis.analyzer.executeandcheck(analyzer.scala:172)","org.apache.spark.sql.catalyst.analysis.analyzer.failanalysis(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.analyzer.org$apache$spark$sql$catalyst$analysis$analyzer$$executesamecontext(analyzer.scala:195)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$$nestedinanonfun$checkanalysis$1$2.applyorelse(checkanalysis.scala:152)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$$nestedinanonfun$checkanalysis$1$2.applyorelse(checkanalysis.scala:155)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1$adapted(checkanalysis.scala:93)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1(checkanalysis.scala:152)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1(checkanalysis.scala:299)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$12$adapted(checkanalysis.scala:272)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$12(checkanalysis.scala:272)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$15$adapted(checkanalysis.scala:299)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$15(checkanalysis.scala:299)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkanalysis$(checkanalysis.scala:90)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkanalysis(checkanalysis.scala:93)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkvalidaggregateexpression$1(checkanalysis.scala:263)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkvalidaggregateexpression$1(checkanalysis.scala:272)","org.apache.spark.sql.catalyst.analysis.checkanalysis.failanalysis$(checkanalysis.scala:49)","org.apache.spark.sql.catalyst.analysis.checkanalysis.failanalysis(checkanalysis.scala:50)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:56)","org.apache.spark.sql.catalyst.plans.logical.analysishelper$.allowinvokingtransformsinanalyzer(analysishelper.scala:221)","org.apache.spark.sql.catalyst.plans.logical.analysishelper$.markinanalyzer(analysishelper.scala:228)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.$anonfun$resolveoperatorsup$1(analysishelper.scala:90)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.$anonfun$resolveoperatorsup$3(analysishelper.scala:90)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.resolveoperatorsup$(analysishelper.scala:84)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.resolveoperatorsup(analysishelper.scala:86)","org.apache.spark.sql.catalyst.plans.logical.logicalplan.resolveoperatorsup(logicalplan.scala:29)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$1(queryplan.scala:116)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$3(queryplan.scala:132)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$4(queryplan.scala:137)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$transformexpressionsup$1(queryplan.scala:104)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:137)","org.apache.spark.sql.catalyst.plans.queryplan.recursivetransform$1(queryplan.scala:127)","org.apache.spark.sql.catalyst.plans.queryplan.recursivetransform$1(queryplan.scala:132)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:116)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:104)","org.apache.spark.sql.catalyst.queryplanningtracker$.withtracker(queryplanningtracker.scala:88)","org.apache.spark.sql.catalyst.queryplanningtracker.measurephase(queryplanningtracker.scala:111)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$execute$1$adapted(ruleexecutor.scala:205)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$execute$1(ruleexecutor.scala:213)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$execute$2(ruleexecutor.scala:216)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$executeandtrack$1(ruleexecutor.scala:183)","org.apache.spark.sql.catalyst.rules.ruleexecutor.execute(ruleexecutor.scala:205)","org.apache.spark.sql.catalyst.rules.ruleexecutor.executeandtrack(ruleexecutor.scala:183)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$1(scalareflection.scala:562)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$1(scalareflection.scala:591)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$6(scalareflection.scala:577)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfortype$1(scalareflection.scala:421)","org.apache.spark.sql.catalyst.scalareflection$.cleanupreflectionobjects(scalareflection.scala:49)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:432)","org.apache.spark.sql.catalyst.scalareflection$.serializerfortype(scalareflection.scala:413)","org.apache.spark.sql.catalyst.scalareflection.cleanupreflectionobjects$(scalareflection.scala:903)","org.apache.spark.sql.catalyst.scalareflection.cleanupreflectionobjects(scalareflection.scala:904)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:73)","org.apache.spark.sql.catalyst.trees.treenode.$anonfun$transformup$2(treenode.scala:341)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:183)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:243)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:341)","org.apache.spark.sql.datafram","org.apache.spark.sql.dataset","org.apache.spark.sql.dataset$.$anonfun$ofrows$1(dataset.scala:90)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:88)","org.apache.spark.sql.dataset.(dataset.scala:210)","org.apache.spark.sql.dataset.(dataset.scala:216)","org.apache.spark.sql.dataset.select(dataset.scala:1462)","org.apache.spark.sql.dataset.select(dataset.scala:1517)","org.apache.spark.sql.dataset.withplan(dataset.scala:3715)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.dataset[org.apache.spark.sql.row]","org.apache.spark.sql.encoders$.product(encoders.scala:285)","org.apache.spark.sql.errors.querycompilationerrors$.morethanonegeneratorerror(querycompilationerrors.scala:95)","org.apache.spark.sql.execution.queryexecution.$anonfun$analyzed$1(queryexecution.scala:73)","org.apache.spark.sql.execution.queryexecution.$anonfun$executephase$1(queryexecution.scala:143)","org.apache.spark.sql.execution.queryexecution.analyzed$lzycompute(queryexecution.scala:73)","org.apache.spark.sql.execution.queryexecution.analyzed(queryexecution.scala:71)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:63)","org.apache.spark.sql.execution.queryexecution.executephase(queryexecution.scala:143)","org.apache.spark.sql.functions.sum","org.apache.spark.sql.functions.{explod","org.apache.spark.sql.lowprioritysqlimplicits.newproductencoder$(sqlimplicits.scala:251)","org.apache.spark.sql.lowprioritysqlimplicits.newproductencoder(sqlimplicits.scala:251)","org.apache.spark.sql.sparksess","org.apache.spark.sql.sparksession.withactive(sparksession.scala:772)","org.apache.spark.sql.sqlcontext","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:32)","org.apache.spark.sql.types.userdefinedtype[a]","org.apache.spark.{sparkconf,","origin","os","other:","otherwise(lit(0.0))).show(8).run()","other|","out","outer","outofmemoryerrors,","over","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","overflow","overhead","overload","overview","overview):","p","packag","pair","parallelcollectionrdd[12]","parallelcollectionrdd[14]","parallelcollectionrdd[16]","parallelcollectionrdd[18]","parallelcollectionrdd[19]","paramet","parquet","parquet,","part","partial","particular","partitionfilters:","pass","peopl","people:","per","perform","performance.","perhap","person","person(age:","person(name:","person(r,","persond","personds:","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","physic","pivot","pivot(aptds('bedrooms)).","pivot,","place","plain","plan","plan,","plan.","plan:","pleas","point,","polymorph","popul","popular","population:","possibl","potenti","practic","pre","precis","predicates.","predict","predict).","predictedcity:","predictedcityindexed.","predictedcityindexed:","predictedprice:","predictions.select(predictions.col('predictedcity)).collect.run()","predictions.select(predictions.col('predictedprice)).collect.run()","predictions:","prefer","preserv","previou","previous","price","price#1386,","price,","price/surfac","price:","price:double)","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.select(pricebysurfaceunit.ascol","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","price|bedrooms|","primit","println(data.cmax)","println(data.cmaxoption)","println(data.cmin)","println(data.cminoption)","println(data.csum)","println(data.csumoption)","probability:","probabl","problem","problem.","problemat","process","product","product,","product.","program","program,","programm","project","project,","project:","projections/selections.","proof","properli","properti","prove","provid","pst","public","pull","pushedfilters:","queri","question","quick","q|","r","rais","random","ratio","ratio:","ratio|","rawprediction:","rdd","rdd.","rdd:","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","rdds,","read","readability.","readabl","readert","readert[io,","readi","readschema).","readschema:","real","reasons,","recommend","recurs","reducebykey","refer","referenc","reflect","relation[i#23l,j#24]","release,","releases.","remind","remov","repl\").set(\"spark.ui.enabled\",","replac","repres","represent","request","requests)","requests.","requir","required:","res16:","res17:","res18:","res19:","res1:","res20:","res2:","res30:","res31:","res32:","res33:","res38:","res45:","res46:","res4:","res5:","res6:","res8:","res9:","residents:","resolut","resolv","result","result.","result.run(spark).unsaferunsync()","result:","resultwithdescription:","rethought","retriev","return","reus","rf","rf.fit(indexeddata).run()","rf.fit(trainingdatawithfeatures)","rf.fit(trainingdatawithfeatures).run()","rf.fit(wrongtrainingdatawithfeatures)","rf:","rfinput","rfinputs(cityindexed:","rfinputs(price:","rfinputs.","right","right?","root","row","run","run()","run:","runtim","runtime.","s:","sadly,","safe","safe,","safe.","safeti","safety!","safety,","safety.","sale","same","sampl","sample.map(_.min)","samplestat","samplestats.show().run()","samplestats:","save","say,","sbt","sc.emptyrdd","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala","scala,","scala.","scala.collection.abstracttraversable.map(traversable.scala:108)","scala.collection.immutable.list.foldleft(list.scala:91)","scala.collection.immutable.list.foreach(list.scala:431)","scala.collection.immutable.list.map(list.scala:293)","scala.collection.immutable.list.map(list.scala:305)","scala.collection.immutable.map[int,int]","scala.collection.immutable.sortedmap","scala.collection.immutable.sortedmap[string,int])]","scala.collection.linearseqoptimized.foldleft$(linearseqoptimized.scala:122)","scala.collection.linearseqoptimized.foldleft(linearseqoptimized.scala:126)","scala.collection.map[string,scala.collection.immutable.sortedmap[string,int]]","scala.collection.map[user,transactioncount]","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:49)","scala.collection.mutable.resizablearray.foreach$(resizablearray.scala:55)","scala.collection.mutable.resizablearray.foreach(resizablearray.scala:62)","scala.collection.traversablelike.$anonfun$map$1(traversablelike.scala:285)","scala.collection.traversablelike.map$(traversablelike.scala:278)","scala.collection.traversablelike.map(traversablelike.scala:285)","scala.reflect.classtag[option[int]])frameless.typedcolumn[w,option[int]]","scala.reflect.internal.tpe.typeconstraints$undolog.undo(typeconstraints.scala:73)","scala>","scalar","scalar,","scalareflect","schema","schema.","seal","second","second,","secondari","section","see","see,","seem","select","select()","select().","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","selectmany()","selectmany(),","semigroup","sense,","separately,","seq(","seq(daterange(new","seq(person(42,","seq[(string,","seq[citybeds]","seq[double]","seq[person]","seq[string]","sequenc","serial","serializ","serializefromobject","serv","set","sever","shadow","shapeless","shapeless'","shapeless.hlist","shapeless.tag.tagged[string(\"citi\")]","shapeless.tag.tagged[string(\"x\")]","shell","shorter","show","show()","show(1).run()","showcas","shown","shuffledrdd[15]","shuffledrdd[17]","sign","signatur","signatures:","similar","similar)","similarly,","simpl","simpli","simplifi","simplist","simply:","since,","singl","situat","size","sizes.","skip","slow","small","snippet,","solut","solv","some(10).map(c","some(3))","some(300000.0),","some(450000.0),","some(50),","some(citybeds(paris,2))","sort","sortedmap(\"task1\"","sortedmap(\"task3\"","sorting.","sourc","spark","spark'","spark).","spark,","spark.","spark.createdataset(","spark.createdataset(apartments)","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark.sparkcontext.setloglevel(\"warn\")","spark:","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparkdelay","sparkdelay[f[_]]","sparkdelay[f].","sparkexplode($\"_2\"))","sparkexplode}","sparksess","sparksession,","sparksession.","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","sqlcontext):","squar","squarefeet:","stack","stack.","stack:","stage","standard","start","stat","statement","statement).","stats(","stay","still","store","strict","stridx_267bc5cb88b4","string","string(\"abc\")","string)","string),updatedsurface]","string):","string)]","string)])","string)],","string,","string.","string]","stringindexerinput","stringindexerinput(city:","stringindexermodel","strongli","struct","struct,","struct]","structur","subsequ","subset","such","suffer","suffici","suggests,","suite:","sum","sum(i)#164l,","sum,","summari","suppli","support","suppos","surfac","surface#1385,","surface,","surface:","surface];","suspend","suspended.","suspens","symbol","syntax","syntax.","syntax:","syntaxes.","system","systems,","t","t.withcolumntupled(","t2","t2.dataset.todf().select(sparkexplode($\"_2\"),","t2.explode('_2):","t2:","t:","t]","tabl","table,","tables:","take","target","task","task2","task3","tdataframe[schema","tdataframe[schema]","techniqu","tell","term","test","test.","testdata","testdata.","testdata:","testdatawithfeatur","testdatawithfeatures:","testinput","testinput:","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","thank","then,","therefore,","thing","this.","those","thread","three","through","throw","thunk","time","time,","time.","time:","timeseri","timeseries)]","togeth","together.","top","topic","totalperus","totalperuser.collectasmap","totalperuser:","toy","trace):","trace,","track","track,","train","trainingdata","trainingdata:","trainingdatawithfeatur","trainingdatawithfeatures:","trait","transactioncount","transactioncount)]","transform","transformations.","tri","troubl","true,","tt,","tune","tupl","tuple23","tutori","tutorial.","two","two.","type","type)","type,","type.","type:","type;","typeclass","typeclass,","typeclass:","typedaggreg","typedcolumn","typedd","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry])","typeddataframe[citymapentry].","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","typeddataset","typeddataset'","typeddataset,","typeddataset.","typeddataset.create(1","typeddataset.create(apartments)","typeddataset.create(apartmentsopt)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset.create(ds)","typeddataset.create(people)","typeddataset.create(seq(","typeddataset.create(seq(\"label\"","typeddataset.create(seq((1,","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset.create(seq(housedata(120,","typeddataset.create(seq(housedata(20,","typeddataset.create(seq(housedata(70,","typeddataset.create(seq(mydate(new","typeddataset.create(seq(wronghousedata(20,","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[(string,int)]","typeddataset[a]","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[apartmentshortinfo]","typeddataset[citybeds]","typeddataset[daterange]","typeddataset[double])","typeddataset[foo]","typeddataset[foodate]","typeddataset[long].","typeddataset[string]","typeddataset[t]","typeddataset[tuple1[a]].","typeddataset[tuple1[long]]","typeddataset[tuplen[...]]","typeddataset[u]","typeddatasets.","typeddatset.","typedds:","typedencod","typedencoder[a]","typedestim","typedestimator,","typedestimators,","typedindextostr","typedindextostring[indextostringinput](indexermodel.transformer.labels)","typedrandomforestclassifi","typedrandomforestclassifier.","typedrandomforestclassifier[rfinputs]","typedrandomforestregressor","typedrandomforestregressor.","typedrandomforestregressor[rfinputs]","typedrandomforestregressor[wrongrfinputs]","typedstringindex","typedstringindexer[stringindexerinput]","typedtransform","typedtransformercan","typedvectorassembl","typedvectorassembler[features]","typedvectorassembler[wrongfeatures]","typeencod","typelevel","types)","types,","types.","types:","typesaf","typesafeti","typo","typo,","u","udf","udf()","udf().","udf(aptds('city),","udf:","ui","unabl","under","underli","unfortun","unfortunately,","union","uniqu","uniquename(name:","unit:","unlik","unsaf","unwrap","up","up,","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","usag","user","user'","usernam","usual","util","val","valid","valu","value#158l]","value#74l]","value,","value.","value:","values.","value|","vanilla","variabl","variou","vector","vector)","vector))","vector,","vector:","vector[string])","vector]","vectorassembl","vectorassembler)","vectorassembler.transform(testdata).as[housedatawithfeatures]","vectorassembler.transform(trainingdata).as[housedatawithfeatures]","vectorassembler:","vectord","vectords:","vectors.dense(1,","vectors:","verbos","veri","verifi","version","versions.","via","view","vs","w:","w](other:","want","warning:","way","way,","well","well,","well.","when(apttypedds2('city)","when/otherwis","whenev","wherea","why?","window","with,","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withcolumn()","withcolumn[citybedsother](lit(list(\"a\",\"b\",\"c\"))).","withcolumntupled()","withdescription(\"sampl","withgroupid(\"samplingjob\").","without","won't","work","work,","worked,","world\")","world|","wrap","wrappedarray((nice,325000.0),","wrappedarray(296250.0)","wrappedarray(6000.0,","wrappedarray(citybeds(paris,2),","wrappedarray(san","written","wrong","wrongfeatur","wrongfeatures(squarefeet:","wronghousedata","wronghousedata(squarefeet:","wronghousedata?","wronghousefeatures(","wrongrfinput","wrongrfinputs(labelofwrongtype:","wrongtrainingdata","wrongtrainingdata:","wrongtrainingdatawithfeatur","wrongtrainingdatawithfeatures:","w|","w})frameless.typedcolumn[w,option[int]]","w})frameless.typedcolumn[w,out]","w},","x","x.","x:","yet.","zero.","{","{lyon,","{nice,","|","|+|","|1000|102|","|100|","|12000.0|","|200000.0|","|276333.3333333333|62.833333333333336|","|300000.0|450000.0|","|4500.0|450000.0|","|6000.0|300000.0|","|6908333.333333333|12.566666666666668|hello","|city|surface|","|lyon|","|null|null|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|paris|[a,","|paris|[abc,","|value|","|{lyon,","|{nice,","|{paris,","}","})","},"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"Introduction","keywords":"","body":"Frameless\n\n\n\n\nFrameless is a Scala library for working with Spark using more expressive types. \nIt consists of the following modules:\n\nframeless-dataset for a more strongly typed Dataset/DataFrame API \nframeless-ml for a more strongly typed Spark ML API based on frameless-dataset\nframeless-cats for using Spark's RDD API with cats\n\nNote that while Frameless is still getting off the ground, it is very possible that breaking changes will be\nmade for at least the next few versions.\nThe Frameless project and contributors support the\nTypelevel Code of Conduct and want all its\nassociated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning.\nVersions and dependencies\nThe compatible versions of Spark and \ncats are as follows: \n\n\n\nFrameless\nSpark\nCats\nCats-Effect\nScala\n\n\n\n\n0.4.0\n2.2.0\n1.0.0-IF\n0.4\n2.11\n\n\n0.4.1\n2.2.0\n1.x\n0.8\n2.11\n\n\n0.5.2\n2.2.1\n1.x\n0.8\n2.11\n\n\n0.6.1\n2.3.0\n1.x\n0.8\n2.11\n\n\n0.7.0\n2.3.1\n1.x\n1.x\n2.11\n\n\n0.8.0\n2.4.0\n1.x\n1.x\n2.11/2.12\n\n\n0.9.0\n3.0.0\n1.x\n1.x\n2.12\n\n\n\nVersions 0.5.x and 0.6.x have identical features. The first is compatible with Spark 2.2.1 and the second with 2.3.0. \nThe only dependency of the frameless-dataset module is on shapeless 2.3.2. \nTherefore, depending on frameless-dataset, has a minimal overhead on your Spark's application jar. \nOnly the frameless-cats module depends on cats and cats-effect, so if you prefer to work just with Datasets and not with RDDs, \nyou may choose not to depend on frameless-cats. \nFrameless intentionally does not have a compile dependency on Spark. \nThis essentially allows you to use any version of Frameless with any version of Spark. \nThe aforementioned table simply provides the versions of Spark we officially compile \nand test Frameless with, but other versions may probably work as well. \nBreaking changes in 0.9\n\nSpark 3 introduces a new ExpressionEncoder approach, the schema for single value DataFrame's is now \"value\" not \"_1\". \n\nWhy?\nFrameless introduces a new Spark API, called TypedDataset. \nThe benefits of using TypedDataset compared to the standard Spark Dataset API are as follows:\n\nTypesafe columns referencing (e.g., no more runtime errors when accessing non-existing columns)\nCustomizable, typesafe encoders (e.g., if a type does not have an encoder, it should not compile) \nEnhanced type signature for built-in functions (e.g., if you apply an arithmetic operation on a non-numeric column, you \nget a compilation error)\nTypesafe casting and projections\n\nClick here for a \ndetailed comparison of TypedDataset with Spark's Dataset API. \nDocumentation\n\nTypedDataset: Feature Overview\nTyped Spark ML\nComparing TypedDatasets with Spark's Datasets\nTyped Encoders in Frameless\nInjection: Creating Custom Encoders\nJob[A]\nUsing Cats with RDDs\nProof of Concept: TypedDataFrame\n\nQuick Start\nSince the 0.9.x release, Frameless is compiled only against Scala 2.12.x.\nTo use Frameless in your project add the following in your build.sbt file as needed:\nval framelessVersion = \"0.9.0\" // for Spark 3.0.0\n\nlibraryDependencies ++= List(\n \"org.typelevel\" %% \"frameless-dataset\" % framelessVersion,\n \"org.typelevel\" %% \"frameless-ml\" % framelessVersion,\n \"org.typelevel\" %% \"frameless-cats\" % framelessVersion \n)\n\nAn easy way to bootstrap a Frameless sbt project:\n\nif you have Giter8 installed then simply:\n\ng8 imarios/frameless.g8\n\n\nwith sbt >= 0.13.13:\n\nsbt new imarios/frameless.g8\n\nTyping sbt console inside your project will bring up a shell with Frameless\nand all its dependencies loaded (including Spark).\nNeed help?\nFeel free to messages us on our gitter \nchannel for any issues/questions.\nDevelopment\nWe require at least one sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers\n(people who can merge pull requests) are:\n\nadelbertc\nimarios\nkanterov\nnon\nOlivierBlanvillain\n\nTesting\nFrameless contains several property tests. To avoid OutOfMemoryErrors, we\ntune the default generator sizes. The following environment variables may\nbe set to adjust the size of generated collections in the TypedDataSet suite:\n\n\n\nProperty\nDefault\n\n\n\n\nFRAMELESS_GEN_MIN_SIZE\n0\n\n\nFRAMELESS_GEN_SIZE_RANGE\n20\n\n\n\nLicense\nCode is provided under the Apache 2.0 license available at http://opensource.org/licenses/Apache-2.0,\nas well as in the LICENSE file. This is the same license used as Spark.\n"},"FeatureOverview.html":{"url":"FeatureOverview.html","title":"TypedDataset: Feature Overview","keywords":"","body":"TypedDataset: Feature Overview\nThis tutorial introduces TypedDataset using a simple example.\nThe following imports are needed to make all code examples compile.\nimport org.apache.spark.{SparkConf, SparkContext}\nimport org.apache.spark.sql.SparkSession\nimport frameless.functions.aggregate._\nimport frameless.TypedDataset\n\nval conf = new SparkConf().setMaster(\"local[*]\").setAppName(\"Frameless repl\").set(\"spark.ui.enabled\", \"false\")\nimplicit val spark = SparkSession.builder().config(conf).appName(\"REPL\").getOrCreate()\nspark.sparkContext.setLogLevel(\"WARN\")\n\nimport spark.implicits._\n\nCreating TypedDataset instances\nWe start by defining a case class:\ncase class Apartment(city: String, surface: Int, price: Double, bedrooms: Int)\n\nAnd few Apartment instances:\nval apartments = Seq(\n Apartment(\"Paris\", 50, 300000.0, 2),\n Apartment(\"Paris\", 100, 450000.0, 3),\n Apartment(\"Paris\", 25, 250000.0, 1),\n Apartment(\"Lyon\", 83, 200000.0, 2),\n Apartment(\"Lyon\", 45, 133000.0, 1),\n Apartment(\"Nice\", 74, 325000.0, 3)\n)\n\nWe are now ready to instantiate a TypedDataset[Apartment]:\nval aptTypedDs = TypedDataset.create(apartments)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nWe can also create one from an existing Spark Dataset:\nval aptDs = spark.createDataset(apartments)\n// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval aptTypedDs = TypedDataset.create(aptDs)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nOr use the Frameless syntax:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval aptTypedDs2 = aptDs.typed\n// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nTypesafe column referencing\nThis is how we select a particular column from a TypedDataset:\nval cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))\n// cities: frameless.TypedDataset[String] = [value: string]\n\nThis is completely type-safe, for instance suppose we misspell city as citi:\naptTypedDs.select(aptTypedDs('citi))\n// :27: error: No column Symbol with shapeless.tag.Tagged[String(\"citi\")] of type A in Apartment\n// aptTypedDs.select(aptTypedDs('citi))\n// ^\n\nThis gets raised at compile time, whereas with the standard Dataset API the error appears at runtime (enjoy the stack trace):\naptDs.select('citi)\n// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [bedrooms, city, price, surface];\n// 'Project ['citi]\n// +- LocalRelation [city#1384, surface#1385, price#1386, bedrooms#1387]\n// \n// at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:155)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:152)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.$anonfun$transformUp$2(TreeNode.scala:341)\n// at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:341)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$transformExpressionsUp$1(QueryPlan.scala:104)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$1(QueryPlan.scala:116)\n// at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:116)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:127)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$3(QueryPlan.scala:132)\n// at scala.collection.TraversableLike.$anonfun$map$1(TraversableLike.scala:285)\n// at scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n// at scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n// at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n// at scala.collection.TraversableLike.map(TraversableLike.scala:285)\n// at scala.collection.TraversableLike.map$(TraversableLike.scala:278)\n// at scala.collection.AbstractTraversable.map(Traversable.scala:108)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:132)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$4(QueryPlan.scala:137)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:243)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:137)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:104)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1(CheckAnalysis.scala:152)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1$adapted(CheckAnalysis.scala:93)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:183)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:93)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:90)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:154)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:175)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)\n// at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)\n// at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)\n// at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)\n// at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n// at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)\n// at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)\n// at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)\n// at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)\n// at org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:90)\n// at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n// at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:88)\n// at org.apache.spark.sql.Dataset.withPlan(Dataset.scala:3715)\n// at org.apache.spark.sql.Dataset.select(Dataset.scala:1462)\n// ... 42 elided\n\nselect() supports arbitrary column operations:\naptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()\n// +----+---+\n// | _1| _2|\n// +----+---+\n// | 500| 52|\n// |1000|102|\n// | 250| 27|\n// | 830| 85|\n// | 450| 47|\n// | 740| 76|\n// +----+---+\n//\n\nNote that unlike the standard Spark API, where some operations are lazy and some are not, all TypedDatasets operations are lazy.\nIn the above example, show() is lazy. It requires to apply run() for the show job to materialize.\nA more detailed explanation of Job is given here.\nNext we compute the price by surface unit:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// :26: error: overloaded method value / with alternatives:\n// (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] \n// [Out, TT, W](other: frameless.TypedColumn[TT,Double])(implicit n: frameless.CatalystDivisible[Double,Out], implicit e: frameless.TypedEncoder[Out], implicit w: frameless.With[Apartment,TT]{type Out = W})frameless.TypedColumn[W,Out]\n// cannot be applied to (frameless.TypedColumn[Apartment,Int])\n// val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// ^\n\nAs the error suggests, we can't divide a TypedColumn of Double by Int.\nFor safety, in Frameless only math operations between same types is allowed:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [value: double]\n\npriceBySurfaceUnit.collect().run()\n// res4: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\nLooks like it worked, but that cast seems unsafe right? Actually it is safe.\nLet's try to cast a TypedColumn of String to Double:\naptTypedDs('city).cast[Double]\n// :27: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]\n// aptTypedDs('city).cast[Double]\n// ^\n\nThe compile-time error tells us that to perform the cast, an evidence\n(in the form of CatalystCast[String, Double]) must be available.\nSince casting from String to Double is not allowed, this results\nin a compilation error.\nCheck here\nfor the set of available CatalystCast.\nWorking with Optional columns\nWhen working with real data we have to deal with imperfections, such as missing fields. Columns that may have\nmissing data should be represented using Options. For this example, let's assume that the Apartments dataset\nmay have missing values. \ncase class ApartmentOpt(city: Option[String], surface: Option[Int], price: Option[Double], bedrooms: Option[Int])\n\nval apartmentsOpt = Seq(\n ApartmentOpt(Some(\"Paris\"), Some(50), Some(300000.0), None),\n ApartmentOpt(None, None, Some(450000.0), Some(3))\n)\n\nval aptTypedDsOpt = TypedDataset.create(apartmentsOpt)\n// aptTypedDsOpt: frameless.TypedDataset[ApartmentOpt] = [city: string, surface: int ... 2 more fields]\n\naptTypedDsOpt.show().run()\n// +-----+-------+--------+--------+\n// | city|surface| price|bedrooms|\n// +-----+-------+--------+--------+\n// |Paris| 50|300000.0| null|\n// | null| null|450000.0| 3|\n// +-----+-------+--------+--------+\n//\n\nUnfortunately the syntax used above with select() will not work here:\naptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()\n// :27: error: overloaded method value * with alternatives:\n// (u: Option[Int])(implicit n: frameless.CatalystNumeric[Option[Int]])frameless.TypedColumn[ApartmentOpt,Option[Int]] \n// [TT, W](other: frameless.TypedColumn[TT,Option[Int]])(implicit n: frameless.CatalystNumeric[Option[Int]], implicit w: frameless.With[ApartmentOpt,TT]{type Out = W}, implicit t: scala.reflect.ClassTag[Option[Int]])frameless.TypedColumn[W,Option[Int]]\n// cannot be applied to (Int)\n// aptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()\n// ^\n// :27: error: overloaded method value + with alternatives:\n// (u: Option[Int])(implicit n: frameless.CatalystNumeric[Option[Int]])frameless.TypedColumn[ApartmentOpt,Option[Int]] \n// [TT, W](other: frameless.TypedColumn[TT,Option[Int]])(implicit n: frameless.CatalystNumeric[Option[Int]], implicit w: frameless.With[ApartmentOpt,TT]{type Out = W})frameless.TypedColumn[W,Option[Int]]\n// cannot be applied to (Int)\n// aptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()\n// ^\n\nThis is because we cannot multiple an Option with an Int. In Scala, Option has a map() method to help address\nexactly this (e.g., Some(10).map(c => c * 2)). Frameless follows a similar convention. By applying the opt method on \nany Option[X] column you can then use map() to provide a function that works with the unwrapped type X. \nThis is best shown in the example bellow:\nscala> aptTypedDsOpt.select(aptTypedDsOpt('surface).opt.map(c => c * 10), aptTypedDsOpt('surface).opt.map(_ + 2)).show().run()\n+----+----+\n| _1| _2|\n+----+----+\n| 500| 52|\n|null|null|\n+----+----+\n\nKnown issue: map() will throw a runtime exception when the applied function includes a udf(). If you want to \napply a udf() to an optional column, we recommend changing your udf to work directly with Optional fields. \nCasting and projections\nIn the general case, select() returns a TypedDataset of type TypedDataset[TupleN[...]] (with N in [1...10]).\nFor example, if we select three columns with types String, Int, and Boolean the result will have type\nTypedDataset[(String, Int, Boolean)]. \nWe often want to give more expressive types to the result of our computations.\nas[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long\nas the types in U and T align.\nWhen the cast is valid the expression compiles:\ncase class UpdatedSurface(city: String, surface: Int)\n// defined class UpdatedSurface\n\nval updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]\n// updated: frameless.TypedDataset[UpdatedSurface] = [city: string, surface: int]\n\nupdated.show(2).run()\n// +-----+-------+\n// | city|surface|\n// +-----+-------+\n// |Paris| 52|\n// |Paris| 102|\n// +-----+-------+\n// only showing top 2 rows\n//\n\nNext we try to cast a (String, String) to an UpdatedSurface (which has types String, Int).\nThe cast is not valid and the expression does not compile:\naptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// :29: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]\n// aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// ^\n\nAdvanced topics with select()\nWhen you select() a single column that has type A, the resulting type is TypedDataset[A] and \nnot TypedDataset[Tuple1[A]]. This behavior makes working with nested schema easier (i.e., in the case \nwhere A is a complex data type) and simplifies type-checking column operations (e.g., verify that two \ncolumns can be added, divided, etc.). However, when A is scalar, say a Long, it makes it harder to select \nand work with the resulting TypedDataset[Long]. For instance, it's harder to reference this single scalar \ncolumn using select(). If this becomes an issue, you can bypass this behavior by using the \nselectMany() method instead of select(). In the previous example, selectMany() will return\nTypedDataset[Tuple1[Long]] and you can reference its single column using the name _1. \nselectMany() should also be used when you need to select more than 10 columns. \nselect() has better IDE support and compiles faster than the macro based selectMany(), \nso prefer select() for the most common use cases.\nWhen you are handed a single scalar column TypedDataset (e.g., TypedDataset[Double]) \nthe best way to reference its single column is using the asCol (short for \"as a column\") method. \nThis is best shown in the example below. We will see more usages of asCol later in this tutorial. \nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [value: double]\n\npriceBySurfaceUnit.select(priceBySurfaceUnit.asCol * 2).show(2).run()\n// +-------+\n// | value|\n// +-------+\n// |12000.0|\n// | 9000.0|\n// +-------+\n// only showing top 2 rows\n//\n\nProjections\nWe often want to work with a subset of the fields in a dataset.\nProjections allow us to easily select our fields of interest\nwhile preserving their initial names and types for extra safety.\nHere is an example using the TypedDataset[Apartment] with an additional column:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\ncase class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)\n// defined class ApartmentDetails\n\nval aptWithRatio =\n aptds.select(\n aptds('city),\n aptds('price),\n aptds('surface),\n aptds('price) / aptds('surface).cast[Double]\n ).as[ApartmentDetails]\n// aptWithRatio: frameless.TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]\n\nSuppose we only want to work with city and ratio:\ncase class CityInfo(city: String, ratio: Double)\n// defined class CityInfo\n\nval cityRatio = aptWithRatio.project[CityInfo]\n// cityRatio: frameless.TypedDataset[CityInfo] = [city: string, ratio: double]\n\ncityRatio.show(2).run()\n// +-----+------+\n// | city| ratio|\n// +-----+------+\n// |Paris|6000.0|\n// |Paris|4500.0|\n// +-----+------+\n// only showing top 2 rows\n//\n\nSuppose we only want to work with price and ratio:\ncase class PriceInfo(ratio: Double, price: Double)\n// defined class PriceInfo\n\nval priceInfo = aptWithRatio.project[PriceInfo]\n// priceInfo: frameless.TypedDataset[PriceInfo] = [ratio: double, price: double]\n\npriceInfo.show(2).run()\n// +------+--------+\n// | ratio| price|\n// +------+--------+\n// |6000.0|300000.0|\n// |4500.0|450000.0|\n// +------+--------+\n// only showing top 2 rows\n//\n\nWe see that the order of the fields does not matter as long as the\nnames and the corresponding types agree. However, if we make a mistake in\nany of the names and/or their types, then we get a compilation error.\nSay we make a typo in a field name:\ncase class PriceInfo2(ratio: Double, pricEE: Double)\n\naptWithRatio.project[PriceInfo2]\n// :29: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?\n// aptWithRatio.project[PriceInfo2]\n// ^\n\nSay we make a mistake in the corresponding type:\ncase class PriceInfo3(ratio: Int, price: Double) // ratio should be Double\n\naptWithRatio.project[PriceInfo3]\n// :29: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?\n// aptWithRatio.project[PriceInfo3]\n// ^\n\nUnion of TypedDatasets\nLets create a projection of our original dataset with a subset of the fields.\ncase class ApartmentShortInfo(city: String, price: Double, bedrooms: Int)\n\nval aptTypedDs2: TypedDataset[ApartmentShortInfo] = aptTypedDs.project[ApartmentShortInfo]\n\nThe union of aptTypedDs2 with aptTypedDs uses all the fields of the caller (aptTypedDs2)\nand expects the other dataset (aptTypedDs) to include all those fields. \nIf field names/types do not match you get a compilation error. \naptTypedDs2.union(aptTypedDs).show().run\n// +-----+--------+--------+\n// | city| price|bedrooms|\n// +-----+--------+--------+\n// |Paris|300000.0| 2|\n// |Paris|450000.0| 3|\n// |Paris|250000.0| 1|\n// | Lyon|200000.0| 2|\n// | Lyon|133000.0| 1|\n// | Nice|325000.0| 3|\n// |Paris|300000.0| 2|\n// |Paris|450000.0| 3|\n// |Paris|250000.0| 1|\n// | Lyon|200000.0| 2|\n// | Lyon|133000.0| 1|\n// | Nice|325000.0| 3|\n// +-----+--------+--------+\n//\n\nThe other way around will not compile, since aptTypedDs2 has only a subset of the fields. \naptTypedDs.union(aptTypedDs2).show().run\n// :28: error: Cannot prove that ApartmentShortInfo can be projected to Apartment. Perhaps not all member names and types of Apartment are the same in ApartmentShortInfo?\n// aptTypedDs.union(aptTypedDs2).show().run\n// ^\n\nFinally, as with project, union will align fields that have same names/types,\nso fields do not have to be in the same order. \nTypedDataset functions and transformations\nFrameless supports many of Spark's functions and transformations. \nHowever, whenever a Spark function does not exist in Frameless, \ncalling .dataset will expose the underlying \nDataset (from org.apache.spark.sql, the original Spark APIs), \nwhere you can use anything that would be missing from the Frameless' API.\nThese are the main imports for Frameless' aggregate and non-aggregate functions.\nimport frameless.functions._ // For literals\nimport frameless.functions.nonAggregate._ // e.g., concat, abs\nimport frameless.functions.aggregate._ // e.g., count, sum, avg\n\nDrop/Replace/Add fields\ndropTupled() drops a single column and results in a tuple-based schema.\naptTypedDs2.dropTupled('price): TypedDataset[(String,Int)]\n// res18: frameless.TypedDataset[(String, Int)] = [_1: string, _2: int]\n\nTo drop a column and specify a new schema use drop().\ncase class CityBeds(city: String, bedrooms: Int)\n// defined class CityBeds\n\nval cityBeds: TypedDataset[CityBeds] = aptTypedDs2.drop[CityBeds] \n// cityBeds: frameless.TypedDataset[CityBeds] = [city: string, bedrooms: int]\n\nOften, you want to replace an existing column with a new value.\nval inflation = aptTypedDs2.withColumnReplaced('price, aptTypedDs2('price) * 2)\n// inflation: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]\n\ninflation.show(2).run()\n// +-----+--------+--------+\n// | city| price|bedrooms|\n// +-----+--------+--------+\n// |Paris|600000.0| 2|\n// |Paris|900000.0| 3|\n// +-----+--------+--------+\n// only showing top 2 rows\n//\n\nOr use a literal instead.\nimport frameless.functions.lit\n// import frameless.functions.lit\n\naptTypedDs2.withColumnReplaced('price, lit(0.001)) \n// res20: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]\n\nAdding a column using withColumnTupled() results in a tupled-based schema.\naptTypedDs2.withColumnTupled(lit(Array(\"a\",\"b\",\"c\"))).show(2).run()\n// +-----+--------+---+---------+\n// | _1| _2| _3| _4|\n// +-----+--------+---+---------+\n// |Paris|300000.0| 2|[a, b, c]|\n// |Paris|450000.0| 3|[a, b, c]|\n// +-----+--------+---+---------+\n// only showing top 2 rows\n//\n\nSimilarly, withColumn() adds a column and explicitly expects a schema for the result.\ncase class CityBedsOther(city: String, bedrooms: Int, other: List[String])\n// defined class CityBedsOther\n\ncityBeds.\n withColumn[CityBedsOther](lit(List(\"a\",\"b\",\"c\"))).\n show(1).run()\n// +-----+--------+---------+\n// | city|bedrooms| other|\n// +-----+--------+---------+\n// |Paris| 2|[a, b, c]|\n// +-----+--------+---------+\n// only showing top 1 row\n//\n\nTo conditionally change a column use the when/otherwise operation. \nimport frameless.functions.nonAggregate.when\n// import frameless.functions.nonAggregate.when\n\naptTypedDs2.withColumnTupled(\n when(aptTypedDs2('city) === \"Paris\", aptTypedDs2('price)).\n when(aptTypedDs2('city) === \"Lyon\", lit(1.1)).\n otherwise(lit(0.0))).show(8).run()\n// +-----+--------+---+--------+\n// | _1| _2| _3| _4|\n// +-----+--------+---+--------+\n// |Paris|300000.0| 2|300000.0|\n// |Paris|450000.0| 3|450000.0|\n// |Paris|250000.0| 1|250000.0|\n// | Lyon|200000.0| 2| 1.1|\n// | Lyon|133000.0| 1| 1.1|\n// | Nice|325000.0| 3| 0.0|\n// +-----+--------+---+--------+\n//\n\nA simple way to add a column without losing important schema information is\nto project the entire source schema into a single column using the asCol() method.\nval c = cityBeds.select(cityBeds.asCol, lit(List(\"a\",\"b\",\"c\")))\n// c: frameless.TypedDataset[(CityBeds, List[String])] = [_1: struct, _2: array]\n\nc.show(1).run()\n// +----------+---------+\n// | _1| _2|\n// +----------+---------+\n// |{Paris, 2}|[a, b, c]|\n// +----------+---------+\n// only showing top 1 row\n//\n\nWhen working with Spark's DataFrames, you often select all columns using .select($\"*\", ...). \nIn a way, asCol() is a typed equivalent of $\"*\". \nTo access nested columns, use the colMany() method. \nc.select(c.colMany('_1, 'city), c('_2)).show(2).run()\n// +-----+---------+\n// | _1| _2|\n// +-----+---------+\n// |Paris|[a, b, c]|\n// |Paris|[a, b, c]|\n// +-----+---------+\n// only showing top 2 rows\n//\n\nWorking with collections\nimport frameless.functions._\n// import frameless.functions._\n\nimport frameless.functions.nonAggregate._\n// import frameless.functions.nonAggregate._\n\nval t = cityRatio.select(cityRatio('city), lit(List(\"abc\",\"c\",\"d\")))\n// t: frameless.TypedDataset[(String, List[String])] = [_1: string, _2: array]\n\nt.withColumnTupled(\n arrayContains(t('_2), \"abc\")\n).show(1).run()\n// +-----+-----------+----+\n// | _1| _2| _3|\n// +-----+-----------+----+\n// |Paris|[abc, c, d]|true|\n// +-----+-----------+----+\n// only showing top 1 row\n//\n\nIf accidentally you apply a collection function on a column that is not a collection,\nyou get a compilation error.\nt.withColumnTupled(\n arrayContains(t('_1), \"abc\")\n)\n// :36: error: no type parameters for method arrayContains: (column: frameless.AbstractTypedColumn[T,C[A]], value: A)(implicit evidence$1: frameless.CatalystCollection[C])column.ThisType[T,Boolean] exist so that it can be applied to arguments (frameless.TypedColumn[(String, List[String]),String], String)\n// --- because ---\n// argument expression's type is not compatible with formal parameter type;\n// found : frameless.TypedColumn[(String, List[String]),String]\n// required: frameless.AbstractTypedColumn[?T,?C[?A]]\n// \n// arrayContains(t('_1), \"abc\")\n// ^\n// :36: error: type mismatch;\n// found : frameless.TypedColumn[(String, List[String]),String]\n// required: frameless.AbstractTypedColumn[T,C[A]]\n// arrayContains(t('_1), \"abc\")\n// ^\n// :36: error: type mismatch;\n// found : String(\"abc\")\n// required: A\n// arrayContains(t('_1), \"abc\")\n// ^\n// :36: error: Cannot do collection operations on columns of type C.\n// arrayContains(t('_1), \"abc\")\n// ^\n\nFlattening columns in Spark is done with the explode() method. Unlike vanilla Spark, \nin Frameless explode() is part of TypedDataset and not a function of a column. \nThis provides additional safety since more than one explode() applied in a single \nstatement results in runtime error in vanilla Spark. \nval t2 = cityRatio.select(cityRatio('city), lit(List(1,2,3,4)))\n// t2: frameless.TypedDataset[(String, List[Int])] = [_1: string, _2: array]\n\nval flattened = t2.explode('_2): TypedDataset[(String, Int)]\n// flattened: frameless.TypedDataset[(String, Int)] = [_1: string, _2: int]\n\nflattened.show(4).run()\n// +-----+---+\n// | _1| _2|\n// +-----+---+\n// |Paris| 1|\n// |Paris| 2|\n// |Paris| 3|\n// |Paris| 4|\n// +-----+---+\n// only showing top 4 rows\n//\n\nHere is an example of how explode() may fail in vanilla Spark. The Frameless \nimplementation does not suffer from this problem since, by design, it can only be applied\nto a single column at a time. \n{\n import org.apache.spark.sql.functions.{explode => sparkExplode}\n t2.dataset.toDF().select(sparkExplode($\"_2\"), sparkExplode($\"_2\"))\n}\n// org.apache.spark.sql.AnalysisException: Only one generator allowed per select clause but found 2: explode(_2), explode(_2)\n// at org.apache.spark.sql.errors.QueryCompilationErrors$.moreThanOneGeneratorError(QueryCompilationErrors.scala:95)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$$anonfun$apply$22.applyOrElse(Analyzer.scala:2510)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$$anonfun$apply$22.applyOrElse(Analyzer.scala:2503)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.$anonfun$resolveOperatorsUp$3(AnalysisHelper.scala:90)\n// at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.$anonfun$resolveOperatorsUp$1(AnalysisHelper.scala:90)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.allowInvokingTransformsInAnalyzer(AnalysisHelper.scala:221)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.resolveOperatorsUp(AnalysisHelper.scala:86)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.resolveOperatorsUp$(AnalysisHelper.scala:84)\n// at org.apache.spark.sql.catalyst.plans.logical.LogicalPlan.resolveOperatorsUp(LogicalPlan.scala:29)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$.apply(Analyzer.scala:2503)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$.apply(Analyzer.scala:2447)\n// at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$2(RuleExecutor.scala:216)\n// at scala.collection.LinearSeqOptimized.foldLeft(LinearSeqOptimized.scala:126)\n// at scala.collection.LinearSeqOptimized.foldLeft$(LinearSeqOptimized.scala:122)\n// at scala.collection.immutable.List.foldLeft(List.scala:91)\n// at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$1(RuleExecutor.scala:213)\n// at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$1$adapted(RuleExecutor.scala:205)\n// at scala.collection.immutable.List.foreach(List.scala:431)\n// at org.apache.spark.sql.catalyst.rules.RuleExecutor.execute(RuleExecutor.scala:205)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.org$apache$spark$sql$catalyst$analysis$Analyzer$$executeSameContext(Analyzer.scala:195)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.execute(Analyzer.scala:189)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.execute(Analyzer.scala:154)\n// at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$executeAndTrack$1(RuleExecutor.scala:183)\n// at org.apache.spark.sql.catalyst.QueryPlanningTracker$.withTracker(QueryPlanningTracker.scala:88)\n// at org.apache.spark.sql.catalyst.rules.RuleExecutor.executeAndTrack(RuleExecutor.scala:183)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:173)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)\n// at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)\n// at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)\n// at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)\n// at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n// at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)\n// at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)\n// at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)\n// at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)\n// at org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:90)\n// at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n// at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:88)\n// at org.apache.spark.sql.Dataset.withPlan(Dataset.scala:3715)\n// at org.apache.spark.sql.Dataset.select(Dataset.scala:1462)\n// ... 42 elided\n\nCollecting data to the driver\nIn Frameless all Spark actions (such as collect()) are safe.\nTake the first element from a dataset (if the dataset is empty return None).\ncityBeds.headOption.run()\n// res30: Option[CityBeds] = Some(CityBeds(Paris,2))\n\nTake the first n elements.\ncityBeds.take(2).run()\n// res31: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3))\n\ncityBeds.head(3).run()\n// res32: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1))\n\ncityBeds.limit(4).collect().run()\n// res33: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1), CityBeds(Lyon,2))\n\nSorting columns\nOnly column types that can be sorted are allowed to be selected for sorting. \naptTypedDs.orderBy(aptTypedDs('city).asc).show(2).run()\n// +----+-------+--------+--------+\n// |city|surface| price|bedrooms|\n// +----+-------+--------+--------+\n// |Lyon| 45|133000.0| 1|\n// |Lyon| 83|200000.0| 2|\n// +----+-------+--------+--------+\n// only showing top 2 rows\n//\n\nThe ordering can be changed by selecting .acs or .desc. \naptTypedDs.orderBy(\n aptTypedDs('city).asc, \n aptTypedDs('price).desc\n).show(2).run()\n// +----+-------+--------+--------+\n// |city|surface| price|bedrooms|\n// +----+-------+--------+--------+\n// |Lyon| 83|200000.0| 2|\n// |Lyon| 45|133000.0| 1|\n// +----+-------+--------+--------+\n// only showing top 2 rows\n//\n\nUser Defined Functions\nFrameless supports lifting any Scala function (up to five arguments) to the\ncontext of a particular TypedDataset:\n// The function we want to use as UDF\nval priceModifier =\n (name: String, price:Double) => if(name == \"Paris\") price * 2.0 else price\n// priceModifier: (String, Double) => Double = \n\nval udf = aptTypedDs.makeUDF(priceModifier)\n// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = frameless.functions.Udf$$Lambda$12549/0x0000000803898840@61521397\n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))\n// adjustedPrice: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\nadjustedPrice.show().run()\n// +-----+--------+\n// | _1| _2|\n// +-----+--------+\n// |Paris|600000.0|\n// |Paris|900000.0|\n// |Paris|500000.0|\n// | Lyon|200000.0|\n// | Lyon|133000.0|\n// | Nice|325000.0|\n// +-----+--------+\n//\n\nGroupBy and Aggregations\nLet's suppose we wanted to retrieve the average apartment price in each city\nval priceByCity = aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('price)))\n// priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\npriceByCity.collect().run()\n// res38: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))\n\nAgain if we try to aggregate a column that can't be aggregated, we get a compilation error\naptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))\n// :35: error: Cannot compute average of type String.\n// aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))\n// ^\n\nNext, we combine select and groupBy to calculate the average price/surface ratio per city:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval cityPriceRatio = aptds.select(aptds('city), aptds('price) / aptds('surface).cast[Double])\n// cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\ncityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()\n// +-----+------------------+\n// | _1| _2|\n// +-----+------------------+\n// | Nice| 4391.891891891892|\n// |Paris| 6833.333333333333|\n// | Lyon|2682.5970548862115|\n// +-----+------------------+\n//\n\nWe can also use pivot to further group data on a secondary column.\nFor example, we can compare the average price across cities by number of bedrooms.\ncase class BedroomStats(\n city: String,\n AvgPriceBeds1: Option[Double], // Pivot values may be missing, so we encode them using Options\n AvgPriceBeds2: Option[Double],\n AvgPriceBeds3: Option[Double],\n AvgPriceBeds4: Option[Double])\n// defined class BedroomStats\n\nval bedroomStats = aptds.\n groupBy(aptds('city)).\n pivot(aptds('bedrooms)).\n on(1,2,3,4). // We only care for up to 4 bedrooms\n agg(avg(aptds('price))).\n as[BedroomStats] // Typesafe casting\n// bedroomStats: frameless.TypedDataset[BedroomStats] = [city: string, AvgPriceBeds1: double ... 3 more fields]\n\nbedroomStats.show().run()\n// +-----+-------------+-------------+-------------+-------------+\n// | city|AvgPriceBeds1|AvgPriceBeds2|AvgPriceBeds3|AvgPriceBeds4|\n// +-----+-------------+-------------+-------------+-------------+\n// | Nice| null| null| 325000.0| null|\n// |Paris| 250000.0| 300000.0| 450000.0| null|\n// | Lyon| 133000.0| 200000.0| null| null|\n// +-----+-------------+-------------+-------------+-------------+\n//\n\nWith pivot, collecting data preserves typesafety by\nencoding potentially missing columns with Option.\nbedroomStats.collect().run().foreach(println)\n// BedroomStats(Nice,None,None,Some(325000.0),None)\n// BedroomStats(Paris,Some(250000.0),Some(300000.0),Some(450000.0),None)\n// BedroomStats(Lyon,Some(133000.0),Some(200000.0),None,None)\n\nWorking with Optional fields\nOptional fields can be converted to non-optional using getOrElse(). \nval sampleStats = bedroomStats.select(\n bedroomStats('AvgPriceBeds2).getOrElse(0.0),\n bedroomStats('AvgPriceBeds3).getOrElse(0.0))\n// sampleStats: frameless.TypedDataset[(Double, Double)] = [_1: double, _2: double]\n\nsampleStats.show().run() \n// +--------+--------+\n// | _1| _2|\n// +--------+--------+\n// | 0.0|325000.0|\n// |300000.0|450000.0|\n// |200000.0| 0.0|\n// +--------+--------+\n//\n\nIn addition, optional columns can be flatten using the .flattenOption method on TypedDatset.\nThe result contains the rows for which the flattened column is not None (or null). The schema\nis automatically adapted to reflect this change.\nval flattenStats = bedroomStats.flattenOption('AvgPriceBeds2)\n// flattenStats: frameless.TypedDataset[this.Out] = [_1: string, _2: double ... 3 more fields]\n\n// The second Option[Double] is now of type Double, since all 'null' values are removed\nflattenStats: TypedDataset[(String, Option[Double], Double, Option[Double], Option[Double])]\n// res45: frameless.TypedDataset[(String, Option[Double], Double, Option[Double], Option[Double])] = [_1: string, _2: double ... 3 more fields]\n\nIn a DataFrame, if you just ignore types, this would equivelantly be written as:\nbedroomStats.dataset.toDF().filter($\"AvgPriceBeds2\".isNotNull)\n// res46: org.apache.spark.sql.Dataset[org.apache.spark.sql.Row] = [city: string, AvgPriceBeds1: double ... 3 more fields]\n\nEntire TypedDataset Aggregation\nWe often want to aggregate the entire TypedDataset and skip the groupBy() clause.\nIn Frameless you can do this using the agg() operator directly on the TypedDataset.\nIn the following example, we compute the average price, the average surface,\nthe minimum surface, and the set of cities for the entire dataset.\ncase class Stats(\n avgPrice: Double,\n avgSurface: Double,\n minSurface: Int,\n allCities: Vector[String])\n// defined class Stats\n\naptds.agg(\n avg(aptds('price)),\n avg(aptds('surface)),\n min(aptds('surface)),\n collectSet(aptds('city))\n).as[Stats].show().run()\n// +-----------------+------------------+----------+-------------------+\n// | avgPrice| avgSurface|minSurface| allCities|\n// +-----------------+------------------+----------+-------------------+\n// |276333.3333333333|62.833333333333336| 25|[Paris, Nice, Lyon]|\n// +-----------------+------------------+----------+-------------------+\n//\n\nYou may apply any TypedColumn operation to a TypedAggregate column as well.\nimport frameless.functions._\n// import frameless.functions._\n\naptds.agg(\n avg(aptds('price)) * min(aptds('surface)).cast[Double], \n avg(aptds('surface)) * 0.2,\n litAggr(\"Hello World\")\n).show().run()\n// +-----------------+------------------+-----------+\n// | _1| _2| _3|\n// +-----------------+------------------+-----------+\n// |6908333.333333333|12.566666666666668|Hello World|\n// +-----------------+------------------+-----------+\n//\n\nJoins\ncase class CityPopulationInfo(name: String, population: Int)\n\nval cityInfo = Seq(\n CityPopulationInfo(\"Paris\", 2229621),\n CityPopulationInfo(\"Lyon\", 500715),\n CityPopulationInfo(\"Nice\", 343629)\n)\n\nval citiInfoTypedDS = TypedDataset.create(cityInfo)\n\nHere is how to join the population information to the apartment's dataset:\nval withCityInfo = aptTypedDs.joinInner(citiInfoTypedDS) { aptTypedDs('city) === citiInfoTypedDS('name) }\n// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct, _2: struct]\n\nwithCityInfo.show().run()\n// +--------------------+----------------+\n// | _1| _2|\n// +--------------------+----------------+\n// |{Paris, 50, 30000...|{Paris, 2229621}|\n// |{Paris, 100, 4500...|{Paris, 2229621}|\n// |{Paris, 25, 25000...|{Paris, 2229621}|\n// |{Lyon, 83, 200000...| {Lyon, 500715}|\n// |{Lyon, 45, 133000...| {Lyon, 500715}|\n// |{Nice, 74, 325000...| {Nice, 343629}|\n// +--------------------+----------------+\n//\n\nThe joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].\nWe can then select which information we want to continue to work with:\ncase class AptPriceCity(city: String, aptPrice: Double, cityPopulation: Int)\n// defined class AptPriceCity\n\nwithCityInfo.select(\n withCityInfo.colMany('_2, 'name), withCityInfo.colMany('_1, 'price), withCityInfo.colMany('_2, 'population)\n).as[AptPriceCity].show().run\n// +-----+--------+--------------+\n// | city|aptPrice|cityPopulation|\n// +-----+--------+--------------+\n// |Paris|300000.0| 2229621|\n// |Paris|450000.0| 2229621|\n// |Paris|250000.0| 2229621|\n// | Lyon|200000.0| 500715|\n// | Lyon|133000.0| 500715|\n// | Nice|325000.0| 343629|\n// +-----+--------+--------------+\n//\n\n"},"TypedDatasetVsSparkDataset.html":{"url":"TypedDatasetVsSparkDataset.html","title":"Comparing TypedDatasets with Spark's Datasets","keywords":"","body":"Comparing TypedDatasets with Spark's Datasets\nGoal:\n This tutorial compares the standard Spark Datasets API with the one provided by\n Frameless' TypedDataset. It shows how TypedDatasets allow for an expressive and\n type-safe api with no compromises on performance.\nFor this tutorial we first create a simple dataset and save it on disk as a parquet file.\nParquet is a popular columnar format and well supported by Spark.\nIt's important to note that when operating on parquet datasets, Spark knows that each column is stored\nseparately, so if we only need a subset of the columns Spark will optimize for this and avoid reading\nthe entire dataset. This is a rather simplistic view of how Spark and parquet work together but it\nwill serve us well for the context of this discussion.\nimport spark.implicits._\n// import spark.implicits._\n\n// Our example case class Foo acting here as a schema\ncase class Foo(i: Long, j: String)\n// defined class Foo\n\n// Assuming spark is loaded and SparkSession is bind to spark\nval initialDs = spark.createDataset( Foo(1, \"Q\") :: Foo(10, \"W\") :: Foo(100, \"E\") :: Nil )\n// initialDs: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\n// Assuming you are on Linux or Mac OS\ninitialDs.write.parquet(\"/tmp/foo\")\n\nval ds = spark.read.parquet(\"/tmp/foo\").as[Foo]\n// ds: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\nds.show()\n// +---+---+\n// | i| j|\n// +---+---+\n// |100| E|\n// | 10| W|\n// | 1| Q|\n// +---+---+\n//\n\nThe value ds holds the content of the initialDs read from a parquet file.\nLet's try to only use field i from Foo and see how Spark's Catalyst (the query optimizer)\noptimizes this.\n// Using a standard Spark TypedColumn in select()\nval filteredDs = ds.filter($\"i\" === 10).select($\"i\".as[Long])\n// filteredDs: org.apache.spark.sql.Dataset[Long] = [i: bigint]\n\nfilteredDs.show()\n// +---+\n// | i|\n// +---+\n// | 10|\n// +---+\n//\n\nThe filteredDs is of type Dataset[Long]. Since we only access field i from Foo the type is correct.\nUnfortunately, this syntax requires handholding by explicitly setting the TypedColumn in the select statement\nto return type Long (look at the as[Long] statement). We will discuss this limitation next in more detail.\nNow, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.\nfilteredDs.explain()\n// == Physical Plan ==\n// *(1) Filter (isnotnull(i#23L) AND (i#23L = 10))\n// +- *(1) ColumnarToRow\n// +- FileScan parquet [i#23L] Batched: true, DataFilters: [isnotnull(i#23L), (i#23L = 10)], Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n// \n//\n\nThe last line is very important (see ReadSchema). The schema read\nfrom the parquet file only required reading column i without needing to access column j.\nThis is great! We have both an optimized query plan and type-safety!\nUnfortunately, this syntax is not bulletproof: it fails at run-time if we try to access\na non existing column x:\nscala> ds.filter($\"i\" === 10).select($\"x\".as[Long])\norg.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];\n'Project ['x]\n+- Filter (i#23L = cast(10 as bigint))\n +- Relation[i#23L,j#24] parquet\n\n at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:155)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:152)\n at org.apache.spark.sql.catalyst.trees.TreeNode.$anonfun$transformUp$2(TreeNode.scala:341)\n at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)\n at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:341)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$transformExpressionsUp$1(QueryPlan.scala:104)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$1(QueryPlan.scala:116)\n at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:116)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:127)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$3(QueryPlan.scala:132)\n at scala.collection.TraversableLike.$anonfun$map$1(TraversableLike.scala:285)\n at scala.collection.immutable.List.foreach(List.scala:431)\n at scala.collection.TraversableLike.map(TraversableLike.scala:285)\n at scala.collection.TraversableLike.map$(TraversableLike.scala:278)\n at scala.collection.immutable.List.map(List.scala:305)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:132)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$4(QueryPlan.scala:137)\n at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:243)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:137)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:104)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1(CheckAnalysis.scala:152)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1$adapted(CheckAnalysis.scala:93)\n at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:183)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:93)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:90)\n at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:154)\n at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:175)\n at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)\n at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)\n at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)\n at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)\n at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)\n at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)\n at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)\n at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)\n at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)\n at org.apache.spark.sql.Dataset.(Dataset.scala:210)\n at org.apache.spark.sql.Dataset.(Dataset.scala:216)\n at org.apache.spark.sql.Dataset.select(Dataset.scala:1517)\n ... 42 elided\n\nThere are two things to improve here. First, we would want to avoid the as[Long] casting that we are required\nto type for type-safety. This is clearly an area where we may introduce a bug by casting to an incompatible\ntype. Second, we want a solution where reference to a non existing column name fails at compilation time.\nThe standard Spark Dataset can achieve this using the following syntax.\nds.filter(_.i == 10).map(_.i).show()\n// +-----+\n// |value|\n// +-----+\n// | 10|\n// +-----+\n//\n\nThis looks great! It reminds us the familiar syntax from Scala.\nThe two closures in filter and map are functions that operate on Foo and the\ncompiler will helps us capture all the mistakes we mentioned above.\nscala> ds.filter(_.i == 10).map(_.x).show()\n:20: error: value x is not a member of Foo\n ds.filter(_.i == 10).map(_.x).show()\n ^\n\nUnfortunately, this syntax does not allow Spark to optimize the code.\nds.filter(_.i == 10).map(_.i).explain()\n// == Physical Plan ==\n// *(1) SerializeFromObject [input[0, bigint, false] AS value#74L]\n// +- *(1) MapElements , obj#73: bigint\n// +- *(1) Filter .apply\n// +- *(1) DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#72: $line14.$read$$iw$$iw$$iw$$iw$Foo\n// +- *(1) ColumnarToRow\n// +- FileScan parquet [i#23L,j#24] Batched: true, DataFilters: [], Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [], ReadSchema: struct\n// \n//\n\nAs we see from the explained Physical Plan, Spark was not able to optimize our query as before.\nReading the parquet file will required loading all the fields of Foo. This might be ok for\nsmall datasets or for datasets with few columns, but will be extremely slow for most practical\napplications. Intuitively, Spark currently does not have a way to look inside the code we pass in these two\nclosures. It only knows that they both take one argument of type Foo, but it has no way of knowing if\nwe use just one or all of Foo's fields.\nThe TypedDataset in Frameless solves this problem. It allows for a simple and type-safe syntax\nwith a fully optimized query plan.\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport frameless.syntax._\n// import frameless.syntax._\n\nval fds = TypedDataset.create(ds)\n// fds: frameless.TypedDataset[Foo] = [i: bigint, j: string]\n\nfds.filter(fds('i) === 10).select(fds('i)).show().run()\n// +-----+\n// |value|\n// +-----+\n// | 10|\n// +-----+\n//\n\nAnd the optimized Physical Plan:\nfds.filter(fds('i) === 10).select(fds('i)).explain()\n// == Physical Plan ==\n// *(1) Project [i#23L AS value#158L]\n// +- *(1) Filter (isnotnull(i#23L) AND (i#23L = 10))\n// +- *(1) ColumnarToRow\n// +- FileScan parquet [i#23L] Batched: true, DataFilters: [isnotnull(i#23L), (i#23L = 10)], Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n// \n//\n\nAnd the compiler is our friend.\nscala> fds.filter(fds('i) === 10).select(fds('x))\n:24: error: No column Symbol with shapeless.tag.Tagged[String(\"x\")] of type A in Foo\n fds.filter(fds('i) === 10).select(fds('x))\n ^\n\nDifferences in Encoders\nEncoders in Spark's Datasets are partially type-safe. If you try to create a Dataset using a type that is not \n a Scala Product then you get a compilation error:\nclass Bar(i: Int)\n// defined class Bar\n\nBar is neither a case class nor a Product, so the following correctly gives a compilation error in Spark:\nscala> spark.createDataset(Seq(new Bar(1)))\n:24: error: Unable to find encoder for type Bar. An implicit Encoder[Bar] is needed to store Bar instances in a Dataset. Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._ Support for serializing other types will be added in future releases.\n spark.createDataset(Seq(new Bar(1)))\n ^\n\nHowever, the compile type guards implemented in Spark are not sufficient to detect non encodable members. \nFor example, using the following case class leads to a runtime failure:\ncase class MyDate(jday: java.util.Date)\n// defined class MyDate\n\nval myDateDs = spark.createDataset(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// java.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n// - field (class: \"java.util.Date\", name: \"jday\")\n// - root class: \"MyDate\"\n// at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:591)\n// at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)\n// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)\n// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$6(ScalaReflection.scala:577)\n// at scala.collection.immutable.List.map(List.scala:293)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:562)\n// at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)\n// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)\n// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerForType$1(ScalaReflection.scala:421)\n// at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)\n// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)\n// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerForType(ScalaReflection.scala:413)\n// at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:56)\n// at org.apache.spark.sql.Encoders$.product(Encoders.scala:285)\n// at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder(SQLImplicits.scala:251)\n// at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder$(SQLImplicits.scala:251)\n// at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:32)\n// ... 42 elided\n\nIn comparison, a TypedDataset will notify about the encoding problem at compile time: \nTypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// :25: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[MyDate]\n// TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// ^\n\nAggregate vs Projected columns\nSpark's Dataset do not distinguish between columns created from aggregate operations, \nsuch as summing or averaging, and simple projections/selections. \nThis is problematic when you start mixing the two.\nimport org.apache.spark.sql.functions.sum\n// import org.apache.spark.sql.functions.sum\n\nds.select(sum($\"i\"), $\"i\"*2)\n// org.apache.spark.sql.AnalysisException: grouping expressions sequence is empty, and '`i`' is not an aggregate function. Wrap '(sum(`i`) AS `sum(i)`)' in windowing function(s) or wrap '`i`' in first() (or first_value) if you don't care which value you get.;\n// Aggregate [sum(i#23L) AS sum(i)#164L, (i#23L * cast(2 as bigint)) AS (i * 2)#165L]\n// +- Relation[i#23L,j#24] parquet\n// \n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.failAnalysis(CheckAnalysis.scala:50)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.failAnalysis$(CheckAnalysis.scala:49)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.failAnalysis(Analyzer.scala:154)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkValidAggregateExpression$1(CheckAnalysis.scala:263)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$12(CheckAnalysis.scala:272)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$12$adapted(CheckAnalysis.scala:272)\n// at scala.collection.immutable.List.foreach(List.scala:431)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkValidAggregateExpression$1(CheckAnalysis.scala:272)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$12(CheckAnalysis.scala:272)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$12$adapted(CheckAnalysis.scala:272)\n// at scala.collection.immutable.List.foreach(List.scala:431)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkValidAggregateExpression$1(CheckAnalysis.scala:272)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$15(CheckAnalysis.scala:299)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$15$adapted(CheckAnalysis.scala:299)\n// at scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n// at scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n// at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1(CheckAnalysis.scala:299)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1$adapted(CheckAnalysis.scala:93)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:183)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:93)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:90)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:154)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:175)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)\n// at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)\n// at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)\n// at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)\n// at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n// at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)\n// at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)\n// at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)\n// at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)\n// at org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:90)\n// at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n// at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:88)\n// at org.apache.spark.sql.Dataset.withPlan(Dataset.scala:3715)\n// at org.apache.spark.sql.Dataset.select(Dataset.scala:1462)\n// ... 42 elided\n\nIn Frameless, mixing the two results in a compilation error.\n// To avoid confusing frameless' sum with the standard Spark's sum\nimport frameless.functions.aggregate.{sum => fsum}\n// import frameless.functions.aggregate.{sum=>fsum}\n\nfds.select(fsum(fds('i)))\n// :26: error: polymorphic expression cannot be instantiated to expected type;\n// found : [Out]frameless.TypedAggregate[Foo,Out]\n// required: frameless.TypedColumn[Foo,?]\n// fds.select(fsum(fds('i)))\n// ^\n\nAs the error suggests, we expected a TypedColumn but we got a TypedAggregate instead. \nHere is how you apply an aggregation method in Frameless: \nfds.agg(fsum(fds('i))+22).show().run()\n// +-----+\n// |value|\n// +-----+\n// | 133|\n// +-----+\n//\n\nSimilarly, mixing projections while aggregating does not make sense, and in Frameless\nyou get a compilation error. \nfds.agg(fsum(fds('i)), fds('i)).show().run()\n// :26: error: polymorphic expression cannot be instantiated to expected type;\n// found : [A]frameless.TypedColumn[Foo,A]\n// required: frameless.TypedAggregate[Foo,?]\n// fds.agg(fsum(fds('i)), fds('i)).show().run()\n// ^\n\n"},"TypedEncoder.html":{"url":"TypedEncoder.html","title":"Typed Encoders in Frameless","keywords":"","body":"Typed Encoders in Frameless\nSpark uses Reflection to derive its Encoders, which is why they can fail at run time. For example, because Spark does not support java.util.Date, the following leads to an error:\nimport org.apache.spark.sql.Dataset\nimport spark.implicits._\n\ncase class DateRange(s: java.util.Date, e: java.util.Date)\n\nscala> val ds: Dataset[DateRange] = Seq(DateRange(new java.util.Date, new java.util.Date)).toDS()\njava.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n- field (class: \"java.util.Date\", name: \"s\")\n- root class: \"DateRange\"\n at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:591)\n at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)\n at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)\n at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)\n at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)\n at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432)\n at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$6(ScalaReflection.scala:577)\n at scala.collection.immutable.List.map(List.scala:293)\n at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:562)\n at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)\n at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)\n at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)\n at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)\n at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432)\n at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerForType$1(ScalaReflection.scala:421)\n at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)\n at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)\n at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)\n at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)\n at org.apache.spark.sql.catalyst.ScalaReflection$.serializerForType(ScalaReflection.scala:413)\n at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:56)\n at org.apache.spark.sql.Encoders$.product(Encoders.scala:285)\n at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder(SQLImplicits.scala:251)\n at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder$(SQLImplicits.scala:251)\n at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:32)\n ... 42 elided\n\nAs shown by the stack trace, this runtime error goes through ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection-based approach is its inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.\nFrameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every Frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless' type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the java.util.Date example won't compile with Frameless:\nimport frameless.TypedDataset\nimport frameless.syntax._\n\nval ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// :28: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]\n// val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// ^\n\nType class derivation takes care of recursively constructing (and proving the existence of) TypeEncoders for case classes. The following works as expected:\ncase class Bar(d: Double, s: String)\n// defined class Bar\n\ncase class Foo(i: Int, b: Bar)\n// defined class Foo\n\nval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, \"s\"))))\n// ds: frameless.TypedDataset[Foo] = [i: int, b: struct]\n\nds.collect()\n// res1: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@77bca0d3\n\nBut any non-encodable in the case class hierarchy will be detected at compile time:\ncase class BarDate(d: Double, s: String, t: java.util.Date)\ncase class FooDate(i: Int, b: BarDate)\n\nval ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// :30: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]\n// val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// ^\n\nIt should be noted that once derived, reflection-based Encoders and implicitly derived TypeEncoders have identical performance. The derivation mechanism is different, but the objects generated to encode and decode JVM objects in Spark's internal representation behave the same at runtime.\n"},"Injection.html":{"url":"Injection.html","title":"Injection: Creating Custom Encoders","keywords":"","body":"Injection: Creating Custom Encoders\nInjection lets us define encoders for types that do not have one by injecting A into an encodable type B.\nThis is the definition of the injection typeclass:\ntrait Injection[A, B] extends Serializable {\n def apply(a: A): B\n def invert(b: B): A\n}\n\nExample\nLet's define a simple case class:\ncase class Person(age: Int, birthday: java.util.Date)\n// defined class Person\n\nval people = Seq(Person(42, new java.util.Date))\n// people: Seq[Person] = List(Person(42,Tue Jan 19 20:29:11 PST 2021))\n\nAnd an instance of a TypedDataset:\nval personDS = TypedDataset.create(people)\n// :23: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n// val personDS = TypedDataset.create(people)\n// ^\n\nLooks like we can't, a TypedEncoder instance of Person is not available, or more precisely for java.util.Date.\nBut we can define a injection from java.util.Date to an encodable type, like Long:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = new Injection[java.util.Date, Long] {\n def apply(d: java.util.Date): Long = d.getTime()\n def invert(l: Long): java.util.Date = new java.util.Date(l)\n}\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@17559031\n\nWe can be less verbose using the Injection.apply function:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@7d716477\n\nNow we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, birthday: bigint]\n\nAnother example\nLet's define a sealed family:\nsealed trait Gender\n// defined trait Gender\n\ncase object Male extends Gender\n// defined object Male\n\ncase object Female extends Gender\n// defined object Female\n\ncase object Other extends Gender\n// defined object Other\n\nAnd a simple case class:\ncase class Person(age: Int, gender: Gender)\n// defined class Person\n\nval people = Seq(Person(42, Male))\n// people: Seq[Person] = List(Person(42,Male))\n\nAgain if we try to create a TypedDataset, we get a compilation error.\nval personDS = TypedDataset.create(people)\n// :31: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n// val personDS = TypedDataset.create(people)\n// ^\n\nLet's define an injection instance for Gender:\nimplicit val genderToInt: Injection[Gender, Int] = Injection(\n {\n case Male => 1\n case Female => 2\n case Other => 3\n },\n {\n case 1 => Male\n case 2 => Female\n case 3 => Other\n })\n// :35: warning: match may not be exhaustive.\n// It would fail on the following inputs: Female, Male, Other\n// {\n// ^\n// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@7c0fbe02\n\nAnd now we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, gender: int]\n\n"},"Job.html":{"url":"Job.html","title":"Job[A]","keywords":"","body":"Job[A]\nAll operations on TypedDataset are lazy. An operation either returns a new\ntransformed TypedDataset or an F[A], where F[_] is a type constructor\nwith an instance of the SparkDelay typeclass and A is the result of running a\nnon-lazy computation in Spark. \nA default such type constructor called Job is provided by Frameless. \nJob serves several functions:\n\nMakes all operations on a TypedDataset lazy, which makes them more predictable compared to having\nfew operations being lazy and other being strict\nAllows the programmer to make expensive blocking operations explicit\nAllows for Spark jobs to be lazily sequenced using monadic composition via for-comprehension\nProvides an obvious place where you can annotate/name your Spark jobs to make it easier\nto track different parts of your application in the Spark UI\n\nThe toy example showcases the use of for-comprehension to explicitly sequences Spark Jobs.\nFirst we calculate the size of the TypedDataset and then we collect to the driver\nexactly 20% of its elements:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval ds = TypedDataset.create(1 to 20)\n// ds: frameless.TypedDataset[Int] = [value: int]\n\nval countAndTakeJob =\n for {\n count \nThe countAndTakeJob can either be executed using run() (as we show above) or it can\nbe passed along to other parts of the program to be further composed into more complex sequences\nof Spark jobs.\nimport frameless.Job\n// import frameless.Job\n\ndef computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min)\n// computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]\n\nval finalJob = computeMinOfSample(countAndTakeJob)\n// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@123416f3\n\nNow we can execute this new job by specifying a group-id and a description.\nThis allows the programmer to see this information on the Spark UI and help track, say,\nperformance issues.\nfinalJob.\n withGroupId(\"samplingJob\").\n withDescription(\"Samples 20% of elements and computes the min\").\n run()\n// res2: Int = 1\n\nMore on SparkDelay\nAs mentioned above, SparkDelay[F[_]] is a typeclass required for suspending\neffects by Spark computations. This typeclass represents the ability to suspend\nan => A thunk into an F[A] value, while implicitly capturing a SparkSession.\nAs it is a typeclass, it is open for implementation by the user in order to use\nother data types for suspension of effects. The cats module, for example, uses\nthis typeclass to support suspending Spark computations in any effect type that\nhas a cats.effect.Sync instance.\n"},"Cats.html":{"url":"Cats.html","title":"Using Cats with RDDs","keywords":"","body":"Using Cats with Frameless\nThere are two main parts to the cats integration offered by Frameless:\n\neffect suspension in TypedDataset using cats-effect and cats-mtl\nRDD enhancements using algebraic typeclasses in cats-kernel\n\nAll the examples below assume you have previously imported cats.implicits and frameless.cats.implicits.\nNote that you should not import frameless.syntax._ together with frameless.cats.implicits._.\nimport cats.implicits._\n// import cats.implicits._\n\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nEffect Suspension in typed datasets\nAs noted in the section about Job, all operations on TypedDataset are lazy. The results of \noperations that would normally block on plain Spark APIs are wrapped in a type constructor F[_], \nfor which there exists an instance of SparkDelay[F]. This typeclass represents the operation of \ndelaying a computation and capturing an implicit SparkSession. \nIn the cats module, we utilize the typeclasses from cats-effect for abstracting over these \neffect types - namely, we provide an implicit SparkDelay instance for all F[_] for which exists\nan instance of cats.effect.Sync[F].\nThis allows one to run operations on TypedDataset in an existing monad stack. For example, given\nthis pre-existing monad stack:\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport cats.data.ReaderT\n// import cats.data.ReaderT\n\nimport cats.effect.IO\n// import cats.effect.IO\n\nimport cats.effect.implicits._\n// import cats.effect.implicits._\n\ntype Action[T] = ReaderT[IO, SparkSession, T]\n// defined type alias Action\n\nWe will be able to request that values from TypedDataset will be suspended in this stack:\nval typedDs = TypedDataset.create(Seq((1, \"string\"), (2, \"another\")))\n// typedDs: frameless.TypedDataset[(Int, String)] = [_1: int, _2: string]\n\nval result: Action[(Seq[(Int, String)], Long)] = for {\n sample \nAs with Job, note that nothing has been run yet. The effect has been properly suspended. To\nrun our program, we must first supply the SparkSession to the ReaderT layer and then\nrun the IO effect:\nresult.run(spark).unsafeRunSync()\n// res5: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)\n\nConvenience methods for modifying Spark thread-local variables\nThe frameless.cats.implicits._ import also provides some syntax enrichments for any monad\nstack that has the same capabilities as Action above. Namely, the ability to provide an\ninstance of SparkSession and the ability to suspend effects.\nFor these to work, we will need to import the implicit machinery from the cats-mtl library:\nimport cats.mtl.implicits._\n// import cats.mtl.implicits._\n\nAnd now, we can set the description for the computation being run:\nval resultWithDescription: Action[(Seq[(Int, String)], Long)] = for {\n r \nUsing algebraic typeclasses from Cats with RDDs\nData aggregation is one of the most important operations when working with Spark (and data in general).\nFor example, we often have to compute the min, max, avg, etc. from a set of columns grouped by\ndifferent predicates. This section shows how cats simplifies these tasks in Spark by\nleveraging a large collection of Type Classes for ordering and aggregating data.\nCats offers ways to sort and aggregate tuples of arbitrary arity.\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nval data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[12] at makeRDD at :43\n\nprintln(data.csum)\n// (10,9,9)\n\nprintln(data.cmax)\n// (8,2,3)\n\nprintln(data.cmin)\n// (1,2,3)\n\nIn case the RDD is empty, the csum, cmax and cmin will use the default values for the type of\nelements inside the RDD. There are counterpart operations to those that have an Option return type\nto deal with the case of an empty RDD:\nval data: RDD[(Int, Int, Int)] = sc.emptyRDD\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = EmptyRDD[13] at emptyRDD at :43\n\nprintln(data.csum)\n// (0,0,0)\n\nprintln(data.csumOption)\n// None\n\nprintln(data.cmax)\n// (0,0,0)\n\nprintln(data.cmaxOption)\n// None\n\nprintln(data.cmin)\n// (0,0,0)\n\nprintln(data.cminOption)\n// None\n\nThe following example aggregates all the elements with a common key.\ntype User = String\n// defined type alias User\n\ntype TransactionCount = Int\n// defined type alias TransactionCount\n\nval allData: RDD[(User,TransactionCount)] =\n sc.makeRDD((\"Bob\", 12) :: (\"Joe\", 1) :: (\"Anna\", 100) :: (\"Bob\", 20) :: (\"Joe\", 2) :: Nil)\n// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[14] at makeRDD at :46\n\nval totalPerUser = allData.csumByKey\n// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[15] at reduceByKey at implicits.scala:42\n\ntotalPerUser.collectAsMap\n// res16: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)\n\nThe same example would work for more complex keys.\nimport scala.collection.immutable.SortedMap\n// import scala.collection.immutable.SortedMap\n\nval allDataComplexKeu =\n sc.makeRDD( (\"Bob\", SortedMap(\"task1\" -> 10)) ::\n (\"Joe\", SortedMap(\"task1\" -> 1, \"task2\" -> 3)) :: (\"Bob\", SortedMap(\"task1\" -> 10, \"task2\" -> 1)) :: (\"Joe\", SortedMap(\"task3\" -> 4)) :: Nil )\n// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ParallelCollectionRDD[16] at makeRDD at :45\n\nval overalTasksPerUser = allDataComplexKeu.csumByKey\n// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ShuffledRDD[17] at reduceByKey at implicits.scala:42\n\noveralTasksPerUser.collectAsMap\n// res17: scala.collection.Map[String,scala.collection.immutable.SortedMap[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))\n\nJoins\n// Type aliases for meaningful types\ntype TimeSeries = Map[Int,Int]\n// defined type alias TimeSeries\n\ntype UserName = String\n// defined type alias UserName\n\nExample: Using the implicit full-our-join operator\nimport frameless.cats.outer._\n// import frameless.cats.outer._\n\nval day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 2, 1 -> 4)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Sam\", Map(0 -> 1)) :: Nil )\n// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[18] at makeRDD at :49\n\nval day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 10, 1 -> 11)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Joe\", Map(0 -> 1, 1 -> 2)) :: Nil )\n// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[19] at makeRDD at :49\n\nval daysCombined = day1 |+| day2\n// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[23] at mapValues at implicits.scala:67\n\ndaysCombined.collect()\n// res19: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))\n\nNote how the user's timeseries from different days have been aggregated together.\nThe |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join\non the key and combine values using the default Semigroup for the value type.\nIn cats:\nMap(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)\n// res20: scala.collection.immutable.Map[Int,Int] = Map(1 -> 6, 2 -> 2)\n\n"},"TypedML.html":{"url":"TypedML.html","title":"Using Spark ML with TypedDataset","keywords":"","body":"Typed Spark ML\nThe frameless-ml module provides a strongly typed Spark ML API leveraging TypedDatasets. It introduces TypedTransformers\nand TypedEstimators, the type-safe equivalents of Spark ML's Transformer and Estimator. \nA TypedEstimator fits models to data, i.e trains a ML model based on an input TypedDataset. \nA TypedTransformer transforms one TypedDataset into another, usually by appending column(s) to it.\nBy calling the fit method of a TypedEstimator, the TypedEstimator will train a ML model using the TypedDataset \npassed as input (representing the training data) and will return a TypedTransformer that represents the trained model. \nThis TypedTransformercan then be used to make predictions on an input TypedDataset (representing the test data) \nusing the transform method that will return a new TypedDataset with appended prediction column(s).\nBoth TypedEstimator and TypedTransformer check at compile-time the correctness of their inputs field names and types,\ncontrary to Spark ML API which only deals with DataFrames (the data structure with the lowest level of type-safety in Spark).\nframeless-ml adds type-safety to Spark ML API but stays very close to it in terms of abstractions and API calls, so \nplease check Spark ML documentation for more details \non Transformers and Estimators.\nExample 1: predict a continuous value using a TypedRandomForestRegressor\nIn this example, we want to predict the sale price of a house depending on its square footage and the fact that the house\nhas a garden or not. We will use a TypedRandomForestRegressor.\nTraining\nAs with the Spark ML API, we use a TypedVectorAssembler (the type-safe equivalent of VectorAssembler)\nto compute feature vectors:\nimport frameless._\nimport frameless.syntax._\nimport frameless.ml._\nimport frameless.ml.feature._\nimport frameless.ml.regression._\nimport org.apache.spark.ml.linalg.Vector\n\ncase class HouseData(squareFeet: Double, hasGarden: Boolean, price: Double)\n// defined class HouseData\n\nval trainingData = TypedDataset.create(Seq(\n HouseData(20, false, 100000),\n HouseData(50, false, 200000),\n HouseData(50, true, 250000),\n HouseData(100, true, 500000)\n))\n// trainingData: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]\n\ncase class Features(squareFeet: Double, hasGarden: Boolean)\n// defined class Features\n\nval assembler = TypedVectorAssembler[Features]\n// assembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@a559710\n\ncase class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector)\n// defined class HouseDataWithFeatures\n\nval trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures]\n// trainingDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]\n\nIn the above code snippet, .as[HouseDataWithFeatures] is a TypedDataset's type-safe cast\n(see TypedDataset: Feature Overview):\ncase class WrongHouseFeatures(\n squareFeet: Double,\n hasGarden: Int, // hasGarden has wrong type\n price: Double,\n features: Vector\n)\n\nassembler.transform(trainingData).as[WrongHouseFeatures]\n// :39: error: could not find implicit value for parameter as: frameless.ops.As[(Double, Boolean, Double, org.apache.spark.ml.linalg.Vector),WrongHouseFeatures]\n// assembler.transform(trainingData).as[WrongHouseFeatures]\n// ^\n\nMoreover, TypedVectorAssembler[Features] will compile only if Features contains exclusively fields of type Numeric or Boolean:\ncase class WrongFeatures(squareFeet: Double, hasGarden: Boolean, city: String)\n\nTypedVectorAssembler[WrongFeatures]\n// :37: error: Cannot prove that WrongFeatures is a valid input type. Input type must only contain fields of numeric or boolean types.\n// TypedVectorAssembler[WrongFeatures]\n// ^\n\nThe subsequent call assembler.transform(trainingData) compiles only if trainingData contains all fields (names and types)\nof Features:\ncase class WrongHouseData(squareFeet: Double, price: Double) // hasGarden is missing\n// defined class WrongHouseData\n\nval wrongTrainingData = TypedDataset.create(Seq(WrongHouseData(20, 100000)))\n// wrongTrainingData: frameless.TypedDataset[WrongHouseData] = [squareFeet: double, price: double]\n\nassembler.transform(wrongTrainingData)\n// :37: error: Cannot prove that WrongHouseData can be projected to Features. Perhaps not all member names and types of Features are the same in WrongHouseData?\n// assembler.transform(wrongTrainingData)\n// ^\n\nThen, we train the model. To train a Random Forest, one needs to feed it with features (what we predict from) and\nwith a label (what we predict). In our example, price is the label, features are the features:\ncase class RFInputs(price: Double, features: Vector)\n// defined class RFInputs\n\nval rf = TypedRandomForestRegressor[RFInputs]\n// rf: frameless.ml.regression.TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@37d61f51\n\nval model = rf.fit(trainingDataWithFeatures).run()\n// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.regression.TypedRandomForestRegressor.Outputs,org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@5d5c3\n\nTypedRandomForestRegressor[RFInputs] compiles only if RFInputs\ncontains only one field of type Double (the label) and one field of type Vector (the features):\ncase class WrongRFInputs(labelOfWrongType: String, features: Vector)\n\nTypedRandomForestRegressor[WrongRFInputs]\n// :37: error: Cannot prove that WrongRFInputs is a valid input type. Input type must only contain a field of type Double (the label) and a field of type org.apache.spark.ml.linalg.Vector (the features).\n// TypedRandomForestRegressor[WrongRFInputs]\n// ^\n\nThe subsequent rf.fit(trainingDataWithFeatures) call compiles only if trainingDataWithFeatures contains the same fields\n(names and types) as RFInputs.\nval wrongTrainingDataWithFeatures = TypedDataset.create(Seq(HouseData(20, false, 100000))) // features are missing\n// wrongTrainingDataWithFeatures: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]\n\nrf.fit(wrongTrainingDataWithFeatures) \n// :37: error: Cannot prove that HouseData can be projected to RFInputs. Perhaps not all member names and types of RFInputs are the same in HouseData?\n// rf.fit(wrongTrainingDataWithFeatures)\n// ^\n\nPrediction\nWe now want to predict price for testData using the previously trained model. Like the Spark ML API,\ntestData has a default value for price (0 in our case) that will be ignored at prediction time. We reuse\nour assembler to compute the feature vector of testData.\nval testData = TypedDataset.create(Seq(HouseData(70, true, 0)))\n// testData: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]\n\nval testDataWithFeatures = assembler.transform(testData).as[HouseDataWithFeatures]\n// testDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]\n\ncase class HousePricePrediction(\n squareFeet: Double,\n hasGarden: Boolean,\n price: Double,\n features: Vector,\n predictedPrice: Double\n)\n// defined class HousePricePrediction\n\nval predictions = model.transform(testDataWithFeatures).as[HousePricePrediction]\n// predictions: frameless.TypedDataset[HousePricePrediction] = [squareFeet: double, hasGarden: boolean ... 3 more fields]\n\npredictions.select(predictions.col('predictedPrice)).collect.run()\n// res6: Seq[Double] = WrappedArray(296250.0)\n\nmodel.transform(testDataWithFeatures) will only compile if testDataWithFeatures contains a field price of type Double\nand a field features of type Vector:\nmodel.transform(testData)\n// :37: error: Cannot prove that HouseData can be projected to RFInputs. Perhaps not all member names and types of RFInputs are the same in HouseData?\n// model.transform(testData)\n// ^\n\nExample 2: predict a categorical value using a TypedRandomForestClassifier\nIn this example, we want to predict in which city a house is located depending on its price and its square footage. We use a\nTypedRandomForestClassifier.\nTraining\nAs with the Spark ML API, we use a TypedVectorAssembler to compute feature vectors and a TypedStringIndexer\nto index city values in order to be able to pass them to a TypedRandomForestClassifier\n(which only accepts Double values as label):\nimport frameless.ml.classification._\n\ncase class HouseData(squareFeet: Double, city: String, price: Double)\n// defined class HouseData\n\nval trainingData = TypedDataset.create(Seq(\n HouseData(100, \"lyon\", 100000),\n HouseData(200, \"lyon\", 200000),\n HouseData(100, \"san francisco\", 500000),\n HouseData(150, \"san francisco\", 900000)\n))\n// trainingData: frameless.TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]\n\ncase class Features(price: Double, squareFeet: Double)\n// defined class Features\n\nval vectorAssembler = TypedVectorAssembler[Features]\n// vectorAssembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@eb06753\n\ncase class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector)\n// defined class HouseDataWithFeatures\n\nval dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures]\n// dataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]\n\ncase class StringIndexerInput(city: String)\n// defined class StringIndexerInput\n\nval indexer = TypedStringIndexer[StringIndexerInput]\n// indexer: frameless.ml.feature.TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@4c2621e0\n\nindexer.estimator.setHandleInvalid(\"keep\")\n// res8: indexer.estimator.type = strIdx_267bc5cb88b4\n\nval indexerModel = indexer.fit(dataWithFeatures).run()\n// indexerModel: frameless.ml.AppendTransformer[StringIndexerInput,frameless.ml.feature.TypedStringIndexer.Outputs,org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@6145e82d\n\ncase class HouseDataWithFeaturesAndIndex(\n squareFeet: Double,\n city: String,\n price: Double,\n features: Vector,\n cityIndexed: Double\n)\n// defined class HouseDataWithFeaturesAndIndex\n\nval indexedData = indexerModel.transform(dataWithFeatures).as[HouseDataWithFeaturesAndIndex]\n// indexedData: frameless.TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]\n\nThen, we train the model:\ncase class RFInputs(cityIndexed: Double, features: Vector)\n// defined class RFInputs\n\nval rf = TypedRandomForestClassifier[RFInputs]\n// rf: frameless.ml.classification.TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@33ab9b32\n\nval model = rf.fit(indexedData).run()\n// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.classification.TypedRandomForestClassifier.Outputs,org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@5bd75b8e\n\nPrediction\nWe now want to predict city for testData using the previously trained model. Like the Spark ML API,\ntestData has a default value for city (empty string in our case) that will be ignored at prediction time. We reuse\nour vectorAssembler to compute the feature vector of testData and our indexerModel to index city.\nval testData = TypedDataset.create(Seq(HouseData(120, \"\", 800000)))\n// testData: frameless.TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]\n\nval testDataWithFeatures = vectorAssembler.transform(testData).as[HouseDataWithFeatures]\n// testDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]\n\nval indexedTestData = indexerModel.transform(testDataWithFeatures).as[HouseDataWithFeaturesAndIndex]\n// indexedTestData: frameless.TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]\n\ncase class HouseCityPredictionInputs(features: Vector, cityIndexed: Double)\n// defined class HouseCityPredictionInputs\n\nval testInput = indexedTestData.project[HouseCityPredictionInputs]\n// testInput: frameless.TypedDataset[HouseCityPredictionInputs] = [features: vector, cityIndexed: double]\n\ncase class HouseCityPredictionIndexed(\n features: Vector,\n cityIndexed: Double,\n rawPrediction: Vector,\n probability: Vector,\n predictedCityIndexed: Double\n)\n// defined class HouseCityPredictionIndexed\n\nval indexedPredictions = model.transform(testInput).as[HouseCityPredictionIndexed]\n// indexedPredictions: frameless.TypedDataset[HouseCityPredictionIndexed] = [features: vector, cityIndexed: double ... 3 more fields]\n\nThen, we use a TypedIndexToString to get back a String value from predictedCityIndexed. TypedIndexToString takes\nas input the label array computed by our previous indexerModel:\ncase class IndexToStringInput(predictedCityIndexed: Double)\n// defined class IndexToStringInput\n\nval indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)\n// :40: warning: method labels in class StringIndexerModel is deprecated (since 3.0.0): `labels` is deprecated and will be removed in 3.1.0. Use `labelsArray` instead.\n// val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)\n// ^\n// indexToString: frameless.ml.feature.TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@355dd92d\n\ncase class HouseCityPrediction(\n features: Vector,\n cityIndexed: Double,\n rawPrediction: Vector,\n probability: Vector,\n predictedCityIndexed: Double,\n predictedCity: String\n)\n// defined class HouseCityPrediction\n\nval predictions = indexToString.transform(indexedPredictions).as[HouseCityPrediction]\n// predictions: frameless.TypedDataset[HouseCityPrediction] = [features: vector, cityIndexed: double ... 4 more fields]\n\npredictions.select(predictions.col('predictedCity)).collect.run()\n// res9: Seq[String] = WrappedArray(san francisco)\n\nList of currently implemented TypedEstimators\n\nTypedRandomForestClassifier\nTypedRandomForestRegressor\n... your contribution here ... :)\n\nList of currently implemented TypedTransformers\n\nTypedIndexToString\nTypedStringIndexer\nTypedVectorAssembler\n... your contribution here ... :)\n\nUsing Vector and Matrix with TypedDataset\nframeless-ml provides TypedEncoder instances for org.apache.spark.ml.linalg.Vector \nand org.apache.spark.ml.linalg.Matrix:\nimport frameless._\nimport frameless.ml._\nimport org.apache.spark.ml.linalg._\n\nval vector = Vectors.dense(1, 2, 3)\n// vector: org.apache.spark.ml.linalg.Vector = [1.0,2.0,3.0]\n\nval vectorDs = TypedDataset.create(Seq(\"label\" -> vector))\n// vectorDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Vector)] = [_1: string, _2: vector]\n\nval matrix = Matrices.dense(2, 1, Array(1, 2))\n// matrix: org.apache.spark.ml.linalg.Matrix =\n// 1.0\n// 2.0\n\nval matrixDs = TypedDataset.create(Seq(\"label\" -> matrix))\n// matrixDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Matrix)] = [_1: string, _2: matrix]\n\nUnder the hood, Vector and Matrix are encoded using org.apache.spark.ml.linalg.VectorUDT \nand org.apache.spark.ml.linalg.MatrixUDT. This is possible thanks to the implicit derivation \nfrom org.apache.spark.sql.types.UserDefinedType[A] to TypedEncoder[A] defined in TypedEncoder companion object.\n"},"TypedDataFrame.html":{"url":"TypedDataFrame.html","title":"Proof of Concept: TypedDataFrame","keywords":"","body":"Proof of Concept: TypedDataFrame\nTypedDataFrame is the API developed in the early stages of Frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future development of Frameless. However, the design is interesting enough to document.\nTo safely manipulate DataFrames we use a technique called a shadow type, which consists in storing additional information about a value in a \"dummy\" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.\nDiving in\nIn TypedDataFrame, we use a single Schema to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:\nimport org.apache.spark.sql.DataFrame\nimport shapeless.HList\n\nclass TDataFrame[Schema Boolean): TDataFrame[Schema] = ???\n\n def select[C \nAs you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.\nType-level column referencing\nFor Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching invalid column references compile type. When everything goes well, Frameless select is very similar to vanilla select, except that it keeps track of the selected column types:\nimport frameless.TypedDataFrame\n\ncase class Foo(s: String, d: Double, i: Int)\n\ndef selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n tf.select('i, 's)\n\nHowever, in case of typo, it gets caught right away:\ndef selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n tf.select('j, 's)\n\nType-level joins\nJoins can available with two different syntaxes. The first lets you reference different columns on each TypedDataFrame, and ensures that they all exist and have compatible types:\ncase class Bar(i: Int, j: String, b: Boolean)\n\ndef join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =\n tf1.innerJoin(tf2).on('s).and('j)\n\nThe second syntax brings some convenience when the joining columns have identical names in both tables:\ndef join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n : TypedDataFrame[(String, Double, Int, String, Boolean)] =\n tf1.innerJoin(tf2).using('i)\n\nFurther example are available in the TypedDataFrame join tests.\nComplete example\nWe now consider a complete example to see how the Frameless types can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city maps and neighborhoods:\ntype Neighborhood = String\ntype Address = String\n\ncase class PhoneBookEntry(\n address: Address,\n residents: String,\n phoneNumber: Double\n)\n\ncase class CityMapEntry(\n address: Address,\n neighborhood: Neighborhood\n)\n\nOur goal will be to compute the neighborhood with unique names, approximating \"unique\" with names containing less common\nletters in the alphabet: 'x', 'q', and 'z'. We are going to need a natural language processing library at some point, so\nlet's use the following for the example:\nobject NLPLib {\n def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))\n}\n\nSuppose we manage to obtain public data for a TypedDataFrame[PhoneBookEntry] and TypedDataFrame[CityMapEntry]. Here is what our Spark job could look like with Frameless:\nimport org.apache.spark.sql.SQLContext\n\n// These case classes are used to hold intermediate results\ncase class Family(residents: String, neighborhood: Neighborhood)\ncase class Person(name: String, neighborhood: Neighborhood)\ncase class NeighborhoodCount(neighborhood: Neighborhood, count: Long)\n\ndef bestNeighborhood\n (phoneBookTF: TypedDataFrame[PhoneBookEntry], cityMapTF: TypedDataFrame[CityMapEntry])\n (implicit c: SQLContext): String = {\n (((((((((\n phoneBookTF\n .innerJoin(cityMapTF).using('address) :TypedDataFrame[(Address, String, Double, String)])\n .select('_2, '_4) :TypedDataFrame[(String, String)])\n .as[Family]() :TypedDataFrame[Family])\n .flatMap { f =>\n f.residents.split(' ').map(r => Person(r, f.neighborhood))\n } :TypedDataFrame[Person])\n .filter { p =>\n NLPLib.uniqueName(p.name)\n } :TypedDataFrame[Person])\n .groupBy('neighborhood).count() :TypedDataFrame[(String, Long)])\n .as[NeighborhoodCount]() :TypedDataFrame[NeighborhoodCount])\n .sortDesc('count) :TypedDataFrame[NeighborhoodCount])\n .select('neighborhood) :TypedDataFrame[Tuple1[String]])\n .head._1\n}\n\nIf you compare this version to vanilla Spark where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.\nLimitations\nThe main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.\nIn the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in Frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.\n"}}} \ No newline at end of file From fb3dc84e302ac38ed0f4ba0121680139f415fcc2 Mon Sep 17 00:00:00 2001 From: pomadchin Date: Wed, 26 Jan 2022 01:09:34 +0000 Subject: [PATCH 006/220] deploy: 9a7df12122ad4c6bd865b2d8c818dfa15781c1d9 --- .github/workflows/ci.yml | 100 - .github/workflows/clean.yml | 59 - .gitignore | 29 - .nojekyll | 0 Cats.html | 731 ++--- FeatureOverview.html | 2022 ++++++-------- Injection.html | 549 +--- Job.html | 509 +--- LICENSE | 201 -- README.md | 142 - TypedDataFrame.html | 590 ++--- TypedDatasetVsSparkDataset.html | 1035 +++----- TypedEncoder.html | 532 +--- TypedML.html | 942 +++---- WorkingWithCsvParquetJson.html | 242 ++ build.sbt | 273 -- .../frameless/cats/FramelessSyntax.scala | 24 - .../frameless/cats/SparkDelayInstances.scala | 11 - .../main/scala/frameless/cats/SparkTask.scala | 14 - .../main/scala/frameless/cats/implicits.scala | 74 - .../main/scala/frameless/cats/package.scala | 9 - cats/src/test/resources/log4j.properties | 146 - .../frameless/cats/FramelessSyntaxTests.scala | 50 - cats/src/test/scala/frameless/cats/test.scala | 129 - .../scala/frameless/CatalystAverageable.scala | 26 - .../scala/frameless/CatalystBitShift.scala | 20 - .../scala/frameless/CatalystBitwise.scala | 20 - .../main/scala/frameless/CatalystCast.scala | 75 - .../scala/frameless/CatalystCollection.scala | 16 - .../scala/frameless/CatalystDivisible.scala | 21 - .../main/scala/frameless/CatalystIsin.scala | 18 - .../main/scala/frameless/CatalystNaN.scala | 16 - .../scala/frameless/CatalystNotNullable.scala | 18 - .../scala/frameless/CatalystNumeric.scala | 19 - .../CatalystNumericWithJavaBigDecimal.scala | 21 - .../scala/frameless/CatalystOrdered.scala | 38 - .../scala/frameless/CatalystPivotable.scala | 16 - .../main/scala/frameless/CatalystRound.scala | 19 - .../scala/frameless/CatalystSummable.scala | 31 - .../scala/frameless/CatalystVariance.scala | 20 - core/src/main/scala/frameless/Injection.scala | 17 - core/src/main/scala/frameless/SQLDate.scala | 9 - .../main/scala/frameless/SQLTimestamp.scala | 9 - .../scala/frameless/FramelessSyntax.scala | 18 - dataset/src/main/scala/frameless/Job.scala | 44 - .../main/scala/frameless/RecordEncoder.scala | 173 -- .../src/main/scala/frameless/SparkDelay.scala | 7 - .../main/scala/frameless/TypedColumn.scala | 908 ------- .../main/scala/frameless/TypedDataset.scala | 1295 --------- .../frameless/TypedDatasetForwarded.scala | 377 --- .../main/scala/frameless/TypedEncoder.scala | 431 --- .../frameless/TypedExpressionEncoder.scala | 46 - .../functions/AggregateFunctions.scala | 277 -- .../main/scala/frameless/functions/Lit.scala | 57 - .../functions/NonAggregateFunctions.scala | 803 ------ .../main/scala/frameless/functions/Udf.scala | 224 -- .../frameless/functions/UnaryFunctions.scala | 95 - .../scala/frameless/functions/package.scala | 35 - .../scala/frameless/ops/AggregateTypes.scala | 28 - dataset/src/main/scala/frameless/ops/As.scala | 40 - .../scala/frameless/ops/ColumnTypes.scala | 28 - .../main/scala/frameless/ops/GroupByOps.scala | 266 -- .../frameless/ops/RelationalGroupsOps.scala | 168 -- .../src/main/scala/frameless/ops/Repeat.scala | 33 - .../scala/frameless/ops/SmartProject.scala | 48 - .../main/scala/frameless/syntax/package.scala | 5 - .../apache/spark/sql/FramelessInternals.scala | 73 - dataset/src/test/resources/log4j.properties | 146 - .../src/test/scala/frameless/AsTests.scala | 53 - .../test/scala/frameless/BitwiseTests.scala | 117 - .../src/test/scala/frameless/CastTests.scala | 111 - .../src/test/scala/frameless/ColTests.scala | 57 - .../test/scala/frameless/CollectTests.scala | 94 - .../test/scala/frameless/ColumnTests.scala | 428 --- .../test/scala/frameless/CreateTests.scala | 153 -- .../src/test/scala/frameless/DropTest.scala | 63 - .../test/scala/frameless/DropTupledTest.scala | 69 - .../test/scala/frameless/EncoderTests.scala | 15 - .../test/scala/frameless/ExplodeTests.scala | 51 - .../test/scala/frameless/FilterTests.scala | 164 -- .../test/scala/frameless/FlattenTests.scala | 29 - .../test/scala/frameless/GroupByTests.scala | 459 ---- .../test/scala/frameless/InjectionTests.scala | 137 - .../src/test/scala/frameless/JobTests.scala | 54 - .../src/test/scala/frameless/JoinTests.scala | 233 -- .../src/test/scala/frameless/LitTests.scala | 65 - .../test/scala/frameless/NumericTests.scala | 206 -- .../test/scala/frameless/OrderByTests.scala | 208 -- .../scala/frameless/RecordEncoderTests.scala | 79 - .../test/scala/frameless/SchemaTests.scala | 54 - .../test/scala/frameless/SelectTests.scala | 399 --- .../test/scala/frameless/SelfJoinTests.scala | 146 - .../scala/frameless/TypedDatasetSuite.scala | 71 - .../scala/frameless/UdtEncodedClass.scala | 47 - .../test/scala/frameless/WithColumnTest.scala | 82 - .../frameless/WithColumnTupledTest.scala | 25 - dataset/src/test/scala/frameless/XN.scala | 92 - .../frameless/forward/CheckpointTests.scala | 21 - .../frameless/forward/ColumnsTests.scala | 30 - .../scala/frameless/forward/CountTests.scala | 14 - .../frameless/forward/DistinctTests.scala | 16 - .../scala/frameless/forward/ExceptTests.scala | 23 - .../scala/frameless/forward/FirstTests.scala | 19 - .../frameless/forward/ForeachTests.scala | 39 - .../scala/frameless/forward/HeadTests.scala | 31 - .../frameless/forward/InputFilesTests.scala | 48 - .../frameless/forward/IntersectTests.scala | 24 - .../frameless/forward/IsLocalTests.scala | 17 - .../frameless/forward/IsStreamingTests.scala | 17 - .../scala/frameless/forward/LimitTests.scala | 20 - .../forward/QueryExecutionTests.scala | 17 - .../frameless/forward/RandomSplitTests.scala | 39 - .../frameless/forward/SQLContextTests.scala | 17 - .../frameless/forward/SparkSessionTests.scala | 17 - .../frameless/forward/StorageLevelTests.scala | 29 - .../scala/frameless/forward/TakeTests.scala | 27 - .../scala/frameless/forward/ToJSONTests.scala | 17 - .../forward/ToLocalIteratorTests.scala | 19 - .../scala/frameless/forward/UnionTests.scala | 66 - .../frameless/forward/WriteStreamTests.scala | 87 - .../scala/frameless/forward/WriteTests.scala | 59 - .../functions/AggregateFunctionsTests.scala | 585 ---- .../DateTimeStringBehaviourUtils.scala | 10 - .../functions/DoubleBehaviourUtils.scala | 20 - .../NonAggregateFunctionsTests.scala | 2358 ----------------- .../scala/frameless/functions/UdfTests.scala | 185 -- .../functions/UnaryFunctionsTest.scala | 141 - .../scala/frameless/ops/ColumnTypesTest.scala | 27 - .../test/scala/frameless/ops/CubeTests.scala | 370 --- .../test/scala/frameless/ops/PivotTest.scala | 98 - .../test/scala/frameless/ops/RepeatTest.scala | 18 - .../scala/frameless/ops/RollupTests.scala | 370 --- .../frameless/ops/SmartProjectTest.scala | 59 - .../ops/deserialized/FilterTests.scala | 19 - .../ops/deserialized/FlatMapTests.scala | 20 - .../ops/deserialized/MapPartitionsTests.scala | 22 - .../frameless/ops/deserialized/MapTests.scala | 21 - .../ops/deserialized/ReduceTests.scala | 23 - .../src/test/scala/frameless/package.scala | 65 - .../syntax/FramelessSyntaxTests.scala | 49 - .../gitbook/fonts/fontawesome/FontAwesome.otf | Bin 124988 -> 0 bytes .../fonts/fontawesome/fontawesome-webfont.eot | Bin 76518 -> 0 bytes .../fonts/fontawesome/fontawesome-webfont.svg | 685 ----- .../fonts/fontawesome/fontawesome-webfont.ttf | Bin 152796 -> 0 bytes .../fontawesome/fontawesome-webfont.woff | Bin 90412 -> 0 bytes .../fontawesome/fontawesome-webfont.woff2 | Bin 71896 -> 0 bytes .../fontsettings.js | 240 -- .../gitbook-plugin-fontsettings/website.css | 291 -- .../gitbook-plugin-highlight/ebook.css | 135 - .../gitbook-plugin-highlight/website.css | 434 --- .../gitbook/gitbook-plugin-lunr/lunr.min.js | 7 - .../gitbook-plugin-lunr/search-lunr.js | 59 - .../gitbook/gitbook-plugin-search/lunr.min.js | 7 - .../gitbook-plugin-search/search-engine.js | 50 - .../gitbook/gitbook-plugin-search/search.css | 35 - .../gitbook/gitbook-plugin-search/search.js | 213 -- .../gitbook/gitbook-plugin-sharing/buttons.js | 90 - docs/book/gitbook/gitbook.js | 4 - .../apple-touch-icon-precomposed-152.png | Bin 4817 -> 0 bytes docs/book/gitbook/images/favicon.ico | Bin 4286 -> 0 bytes docs/book/gitbook/style.css | 9 - docs/book/gitbook/theme.js | 4 - docs/src/main/tut/Cats.md | 198 -- docs/src/main/tut/FeatureOverview.md | 651 ----- docs/src/main/tut/Injection.md | 111 - docs/src/main/tut/Job.md | 87 - docs/src/main/tut/README.md | 142 - docs/src/main/tut/SUMMARY.md | 8 - docs/src/main/tut/TypedDataFrame.md | 139 - .../main/tut/TypedDatasetVsSparkDataset.md | 210 -- docs/src/main/tut/TypedEncoder.md | 62 - docs/src/main/tut/TypedML.md | 305 --- gitbook/fonts/fontawesome/FontAwesome.otf | Bin 124988 -> 0 bytes .../fonts/fontawesome/fontawesome-webfont.eot | Bin 76518 -> 0 bytes .../fonts/fontawesome/fontawesome-webfont.svg | 685 ----- .../fonts/fontawesome/fontawesome-webfont.ttf | Bin 152796 -> 0 bytes .../fontawesome/fontawesome-webfont.woff | Bin 90412 -> 0 bytes .../fontawesome/fontawesome-webfont.woff2 | Bin 71896 -> 0 bytes .../fontsettings.js | 240 -- .../gitbook-plugin-fontsettings/website.css | 291 -- gitbook/gitbook-plugin-highlight/ebook.css | 135 - gitbook/gitbook-plugin-highlight/website.css | 434 --- gitbook/gitbook-plugin-lunr/lunr.min.js | 7 - gitbook/gitbook-plugin-lunr/search-lunr.js | 59 - gitbook/gitbook-plugin-search/lunr.min.js | 7 - .../gitbook-plugin-search/search-engine.js | 50 - gitbook/gitbook-plugin-search/search.css | 35 - gitbook/gitbook-plugin-search/search.js | 213 -- gitbook/gitbook-plugin-sharing/buttons.js | 90 - gitbook/gitbook.js | 4 - .../apple-touch-icon-precomposed-152.png | Bin 4817 -> 0 bytes gitbook/images/favicon.ico | Bin 4286 -> 0 bytes gitbook/style.css | 9 - gitbook/theme.js | 4 - helium/fonts/icofont.woff | Bin 0 -> 3540 bytes helium/fonts/icofont.woff2 | Bin 0 -> 2940 bytes helium/icofont.min.css | 7 + helium/laika-helium.css | 853 ++++++ helium/laika-helium.js | 44 + helium/landing.page.css | 142 + index.html | 771 ++---- iris.data | 151 ++ iris.parquet | Bin 0 -> 2597 bytes .../scala/frameless/ml/TypedEstimator.scala | 27 - .../scala/frameless/ml/TypedTransformer.scala | 41 - .../TypedRandomForestClassifier.scala | 51 - .../ml/clustering/TypedBisectingKMeans.scala | 49 - .../frameless/ml/clustering/TypedKMeans.scala | 45 - .../ml/feature/TypedIndexToString.scala | 32 - .../ml/feature/TypedStringIndexer.scala | 42 - .../ml/feature/TypedVectorAssembler.scala | 69 - .../ml/internals/LinearInputsChecker.scala | 70 - .../ml/internals/SelectorByValue.scala | 29 - .../ml/internals/TreesInputsChecker.scala | 45 - .../ml/internals/UnaryInputsChecker.scala | 33 - .../ml/internals/VectorInputsChecker.scala | 32 - ml/src/main/scala/frameless/ml/package.scala | 13 - .../ml/params/kmeans/KMeansInitMode.scala | 19 - .../ml/params/linears/LossStrategy.scala | 16 - .../frameless/ml/params/linears/Solver.scala | 25 - .../params/trees/FeatureSubsetStrategy.scala | 39 - .../ml/regression/TypedLinearRegression.scala | 52 - .../TypedRandomForestRegressor.scala | 47 - .../apache/spark/ml/FramelessInternals.scala | 13 - .../scala/frameless/ml/FramelessMlSuite.scala | 14 - .../test/scala/frameless/ml/Generators.scala | 57 - .../ml/TypedEncoderInstancesTests.scala | 55 - .../ClassificationIntegrationTests.scala | 74 - .../TypedRandomForestClassifierTests.scala | 89 - .../ml/clustering/BisectingKMeansTests.scala | 55 - .../ClusteringIntegrationTests.scala | 73 - .../frameless/ml/clustering/KMeansTests.scala | 71 - .../ml/feature/TypedIndexToStringTests.scala | 34 - .../ml/feature/TypedStringIndexerTests.scala | 50 - .../feature/TypedVectorAssemblerTests.scala | 44 - .../RegressionIntegrationTests.scala | 44 - .../TypedLinearRegressionTests.scala | 126 - .../TypedRandomForestRegressorTests.scala | 87 - project/build.properties | 1 - project/plugins.sbt | 5 - scripts/docs-build.sh | 18 - scripts/docs-publish.sh | 25 - scripts/travis-publish.sh | 27 - search_index.json | 1 - version.sbt | 1 - 245 files changed, 4132 insertions(+), 29416 deletions(-) delete mode 100644 .github/workflows/ci.yml delete mode 100644 .github/workflows/clean.yml delete mode 100644 .gitignore create mode 100644 .nojekyll delete mode 100644 LICENSE delete mode 100644 README.md create mode 100644 WorkingWithCsvParquetJson.html delete mode 100644 build.sbt delete mode 100644 cats/src/main/scala/frameless/cats/FramelessSyntax.scala delete mode 100644 cats/src/main/scala/frameless/cats/SparkDelayInstances.scala delete mode 100644 cats/src/main/scala/frameless/cats/SparkTask.scala delete mode 100644 cats/src/main/scala/frameless/cats/implicits.scala delete mode 100644 cats/src/main/scala/frameless/cats/package.scala delete mode 100644 cats/src/test/resources/log4j.properties delete mode 100644 cats/src/test/scala/frameless/cats/FramelessSyntaxTests.scala delete mode 100644 cats/src/test/scala/frameless/cats/test.scala delete mode 100644 core/src/main/scala/frameless/CatalystAverageable.scala delete mode 100644 core/src/main/scala/frameless/CatalystBitShift.scala delete mode 100644 core/src/main/scala/frameless/CatalystBitwise.scala delete mode 100644 core/src/main/scala/frameless/CatalystCast.scala delete mode 100644 core/src/main/scala/frameless/CatalystCollection.scala delete mode 100644 core/src/main/scala/frameless/CatalystDivisible.scala delete mode 100644 core/src/main/scala/frameless/CatalystIsin.scala delete mode 100644 core/src/main/scala/frameless/CatalystNaN.scala delete mode 100644 core/src/main/scala/frameless/CatalystNotNullable.scala delete mode 100644 core/src/main/scala/frameless/CatalystNumeric.scala delete mode 100644 core/src/main/scala/frameless/CatalystNumericWithJavaBigDecimal.scala delete mode 100644 core/src/main/scala/frameless/CatalystOrdered.scala delete mode 100644 core/src/main/scala/frameless/CatalystPivotable.scala delete mode 100644 core/src/main/scala/frameless/CatalystRound.scala delete mode 100644 core/src/main/scala/frameless/CatalystSummable.scala delete mode 100644 core/src/main/scala/frameless/CatalystVariance.scala delete mode 100644 core/src/main/scala/frameless/Injection.scala delete mode 100644 core/src/main/scala/frameless/SQLDate.scala delete mode 100644 core/src/main/scala/frameless/SQLTimestamp.scala delete mode 100644 dataset/src/main/scala/frameless/FramelessSyntax.scala delete mode 100644 dataset/src/main/scala/frameless/Job.scala delete mode 100644 dataset/src/main/scala/frameless/RecordEncoder.scala delete mode 100644 dataset/src/main/scala/frameless/SparkDelay.scala delete mode 100644 dataset/src/main/scala/frameless/TypedColumn.scala delete mode 100644 dataset/src/main/scala/frameless/TypedDataset.scala delete mode 100644 dataset/src/main/scala/frameless/TypedDatasetForwarded.scala delete mode 100644 dataset/src/main/scala/frameless/TypedEncoder.scala delete mode 100644 dataset/src/main/scala/frameless/TypedExpressionEncoder.scala delete mode 100644 dataset/src/main/scala/frameless/functions/AggregateFunctions.scala delete mode 100644 dataset/src/main/scala/frameless/functions/Lit.scala delete mode 100644 dataset/src/main/scala/frameless/functions/NonAggregateFunctions.scala delete mode 100644 dataset/src/main/scala/frameless/functions/Udf.scala delete mode 100644 dataset/src/main/scala/frameless/functions/UnaryFunctions.scala delete mode 100644 dataset/src/main/scala/frameless/functions/package.scala delete mode 100644 dataset/src/main/scala/frameless/ops/AggregateTypes.scala delete mode 100644 dataset/src/main/scala/frameless/ops/As.scala delete mode 100644 dataset/src/main/scala/frameless/ops/ColumnTypes.scala delete mode 100644 dataset/src/main/scala/frameless/ops/GroupByOps.scala delete mode 100644 dataset/src/main/scala/frameless/ops/RelationalGroupsOps.scala delete mode 100644 dataset/src/main/scala/frameless/ops/Repeat.scala delete mode 100644 dataset/src/main/scala/frameless/ops/SmartProject.scala delete mode 100644 dataset/src/main/scala/frameless/syntax/package.scala delete mode 100644 dataset/src/main/scala/org/apache/spark/sql/FramelessInternals.scala delete mode 100644 dataset/src/test/resources/log4j.properties delete mode 100644 dataset/src/test/scala/frameless/AsTests.scala delete mode 100644 dataset/src/test/scala/frameless/BitwiseTests.scala delete mode 100644 dataset/src/test/scala/frameless/CastTests.scala delete mode 100644 dataset/src/test/scala/frameless/ColTests.scala delete mode 100644 dataset/src/test/scala/frameless/CollectTests.scala delete mode 100644 dataset/src/test/scala/frameless/ColumnTests.scala delete mode 100644 dataset/src/test/scala/frameless/CreateTests.scala delete mode 100644 dataset/src/test/scala/frameless/DropTest.scala delete mode 100644 dataset/src/test/scala/frameless/DropTupledTest.scala delete mode 100644 dataset/src/test/scala/frameless/EncoderTests.scala delete mode 100644 dataset/src/test/scala/frameless/ExplodeTests.scala delete mode 100644 dataset/src/test/scala/frameless/FilterTests.scala delete mode 100644 dataset/src/test/scala/frameless/FlattenTests.scala delete mode 100644 dataset/src/test/scala/frameless/GroupByTests.scala delete mode 100644 dataset/src/test/scala/frameless/InjectionTests.scala delete mode 100644 dataset/src/test/scala/frameless/JobTests.scala delete mode 100644 dataset/src/test/scala/frameless/JoinTests.scala delete mode 100644 dataset/src/test/scala/frameless/LitTests.scala delete mode 100644 dataset/src/test/scala/frameless/NumericTests.scala delete mode 100644 dataset/src/test/scala/frameless/OrderByTests.scala delete mode 100644 dataset/src/test/scala/frameless/RecordEncoderTests.scala delete mode 100644 dataset/src/test/scala/frameless/SchemaTests.scala delete mode 100644 dataset/src/test/scala/frameless/SelectTests.scala delete mode 100644 dataset/src/test/scala/frameless/SelfJoinTests.scala delete mode 100644 dataset/src/test/scala/frameless/TypedDatasetSuite.scala delete mode 100644 dataset/src/test/scala/frameless/UdtEncodedClass.scala delete mode 100644 dataset/src/test/scala/frameless/WithColumnTest.scala delete mode 100644 dataset/src/test/scala/frameless/WithColumnTupledTest.scala delete mode 100644 dataset/src/test/scala/frameless/XN.scala delete mode 100644 dataset/src/test/scala/frameless/forward/CheckpointTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/ColumnsTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/CountTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/DistinctTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/ExceptTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/FirstTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/ForeachTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/HeadTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/InputFilesTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/IntersectTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/IsLocalTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/IsStreamingTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/LimitTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/QueryExecutionTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/RandomSplitTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/SQLContextTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/SparkSessionTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/StorageLevelTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/TakeTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/ToJSONTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/ToLocalIteratorTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/UnionTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/WriteStreamTests.scala delete mode 100644 dataset/src/test/scala/frameless/forward/WriteTests.scala delete mode 100644 dataset/src/test/scala/frameless/functions/AggregateFunctionsTests.scala delete mode 100644 dataset/src/test/scala/frameless/functions/DateTimeStringBehaviourUtils.scala delete mode 100644 dataset/src/test/scala/frameless/functions/DoubleBehaviourUtils.scala delete mode 100644 dataset/src/test/scala/frameless/functions/NonAggregateFunctionsTests.scala delete mode 100644 dataset/src/test/scala/frameless/functions/UdfTests.scala delete mode 100644 dataset/src/test/scala/frameless/functions/UnaryFunctionsTest.scala delete mode 100644 dataset/src/test/scala/frameless/ops/ColumnTypesTest.scala delete mode 100644 dataset/src/test/scala/frameless/ops/CubeTests.scala delete mode 100644 dataset/src/test/scala/frameless/ops/PivotTest.scala delete mode 100644 dataset/src/test/scala/frameless/ops/RepeatTest.scala delete mode 100644 dataset/src/test/scala/frameless/ops/RollupTests.scala delete mode 100644 dataset/src/test/scala/frameless/ops/SmartProjectTest.scala delete mode 100644 dataset/src/test/scala/frameless/ops/deserialized/FilterTests.scala delete mode 100644 dataset/src/test/scala/frameless/ops/deserialized/FlatMapTests.scala delete mode 100644 dataset/src/test/scala/frameless/ops/deserialized/MapPartitionsTests.scala delete mode 100644 dataset/src/test/scala/frameless/ops/deserialized/MapTests.scala delete mode 100644 dataset/src/test/scala/frameless/ops/deserialized/ReduceTests.scala delete mode 100644 dataset/src/test/scala/frameless/package.scala delete mode 100644 dataset/src/test/scala/frameless/syntax/FramelessSyntaxTests.scala delete mode 100644 docs/book/gitbook/fonts/fontawesome/FontAwesome.otf delete mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.eot delete mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.svg delete mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.ttf delete mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff delete mode 100644 docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff2 delete mode 100644 docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js delete mode 100644 docs/book/gitbook/gitbook-plugin-fontsettings/website.css delete mode 100644 docs/book/gitbook/gitbook-plugin-highlight/ebook.css delete mode 100644 docs/book/gitbook/gitbook-plugin-highlight/website.css delete mode 100644 docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js delete mode 100644 docs/book/gitbook/gitbook-plugin-lunr/search-lunr.js delete mode 100644 docs/book/gitbook/gitbook-plugin-search/lunr.min.js delete mode 100644 docs/book/gitbook/gitbook-plugin-search/search-engine.js delete mode 100644 docs/book/gitbook/gitbook-plugin-search/search.css delete mode 100644 docs/book/gitbook/gitbook-plugin-search/search.js delete mode 100644 docs/book/gitbook/gitbook-plugin-sharing/buttons.js delete mode 100644 docs/book/gitbook/gitbook.js delete mode 100644 docs/book/gitbook/images/apple-touch-icon-precomposed-152.png delete mode 100644 docs/book/gitbook/images/favicon.ico delete mode 100644 docs/book/gitbook/style.css delete mode 100644 docs/book/gitbook/theme.js delete mode 100644 docs/src/main/tut/Cats.md delete mode 100644 docs/src/main/tut/FeatureOverview.md delete mode 100644 docs/src/main/tut/Injection.md delete mode 100644 docs/src/main/tut/Job.md delete mode 100644 docs/src/main/tut/README.md delete mode 100644 docs/src/main/tut/SUMMARY.md delete mode 100644 docs/src/main/tut/TypedDataFrame.md delete mode 100644 docs/src/main/tut/TypedDatasetVsSparkDataset.md delete mode 100644 docs/src/main/tut/TypedEncoder.md delete mode 100644 docs/src/main/tut/TypedML.md delete mode 100644 gitbook/fonts/fontawesome/FontAwesome.otf delete mode 100644 gitbook/fonts/fontawesome/fontawesome-webfont.eot delete mode 100644 gitbook/fonts/fontawesome/fontawesome-webfont.svg delete mode 100644 gitbook/fonts/fontawesome/fontawesome-webfont.ttf delete mode 100644 gitbook/fonts/fontawesome/fontawesome-webfont.woff delete mode 100644 gitbook/fonts/fontawesome/fontawesome-webfont.woff2 delete mode 100644 gitbook/gitbook-plugin-fontsettings/fontsettings.js delete mode 100644 gitbook/gitbook-plugin-fontsettings/website.css delete mode 100644 gitbook/gitbook-plugin-highlight/ebook.css delete mode 100644 gitbook/gitbook-plugin-highlight/website.css delete mode 100644 gitbook/gitbook-plugin-lunr/lunr.min.js delete mode 100644 gitbook/gitbook-plugin-lunr/search-lunr.js delete mode 100644 gitbook/gitbook-plugin-search/lunr.min.js delete mode 100644 gitbook/gitbook-plugin-search/search-engine.js delete mode 100644 gitbook/gitbook-plugin-search/search.css delete mode 100644 gitbook/gitbook-plugin-search/search.js delete mode 100644 gitbook/gitbook-plugin-sharing/buttons.js delete mode 100644 gitbook/gitbook.js delete mode 100644 gitbook/images/apple-touch-icon-precomposed-152.png delete mode 100644 gitbook/images/favicon.ico delete mode 100644 gitbook/style.css delete mode 100644 gitbook/theme.js create mode 100644 helium/fonts/icofont.woff create mode 100644 helium/fonts/icofont.woff2 create mode 100644 helium/icofont.min.css create mode 100644 helium/laika-helium.css create mode 100644 helium/laika-helium.js create mode 100644 helium/landing.page.css create mode 100644 iris.data create mode 100644 iris.parquet delete mode 100644 ml/src/main/scala/frameless/ml/TypedEstimator.scala delete mode 100644 ml/src/main/scala/frameless/ml/TypedTransformer.scala delete mode 100644 ml/src/main/scala/frameless/ml/classification/TypedRandomForestClassifier.scala delete mode 100644 ml/src/main/scala/frameless/ml/clustering/TypedBisectingKMeans.scala delete mode 100644 ml/src/main/scala/frameless/ml/clustering/TypedKMeans.scala delete mode 100644 ml/src/main/scala/frameless/ml/feature/TypedIndexToString.scala delete mode 100644 ml/src/main/scala/frameless/ml/feature/TypedStringIndexer.scala delete mode 100644 ml/src/main/scala/frameless/ml/feature/TypedVectorAssembler.scala delete mode 100644 ml/src/main/scala/frameless/ml/internals/LinearInputsChecker.scala delete mode 100644 ml/src/main/scala/frameless/ml/internals/SelectorByValue.scala delete mode 100644 ml/src/main/scala/frameless/ml/internals/TreesInputsChecker.scala delete mode 100644 ml/src/main/scala/frameless/ml/internals/UnaryInputsChecker.scala delete mode 100644 ml/src/main/scala/frameless/ml/internals/VectorInputsChecker.scala delete mode 100644 ml/src/main/scala/frameless/ml/package.scala delete mode 100644 ml/src/main/scala/frameless/ml/params/kmeans/KMeansInitMode.scala delete mode 100644 ml/src/main/scala/frameless/ml/params/linears/LossStrategy.scala delete mode 100644 ml/src/main/scala/frameless/ml/params/linears/Solver.scala delete mode 100644 ml/src/main/scala/frameless/ml/params/trees/FeatureSubsetStrategy.scala delete mode 100644 ml/src/main/scala/frameless/ml/regression/TypedLinearRegression.scala delete mode 100644 ml/src/main/scala/frameless/ml/regression/TypedRandomForestRegressor.scala delete mode 100644 ml/src/main/scala/org/apache/spark/ml/FramelessInternals.scala delete mode 100644 ml/src/test/scala/frameless/ml/FramelessMlSuite.scala delete mode 100644 ml/src/test/scala/frameless/ml/Generators.scala delete mode 100644 ml/src/test/scala/frameless/ml/TypedEncoderInstancesTests.scala delete mode 100644 ml/src/test/scala/frameless/ml/classification/ClassificationIntegrationTests.scala delete mode 100644 ml/src/test/scala/frameless/ml/classification/TypedRandomForestClassifierTests.scala delete mode 100644 ml/src/test/scala/frameless/ml/clustering/BisectingKMeansTests.scala delete mode 100644 ml/src/test/scala/frameless/ml/clustering/ClusteringIntegrationTests.scala delete mode 100644 ml/src/test/scala/frameless/ml/clustering/KMeansTests.scala delete mode 100644 ml/src/test/scala/frameless/ml/feature/TypedIndexToStringTests.scala delete mode 100644 ml/src/test/scala/frameless/ml/feature/TypedStringIndexerTests.scala delete mode 100644 ml/src/test/scala/frameless/ml/feature/TypedVectorAssemblerTests.scala delete mode 100644 ml/src/test/scala/frameless/ml/regression/RegressionIntegrationTests.scala delete mode 100644 ml/src/test/scala/frameless/ml/regression/TypedLinearRegressionTests.scala delete mode 100644 ml/src/test/scala/frameless/ml/regression/TypedRandomForestRegressorTests.scala delete mode 100644 project/build.properties delete mode 100644 project/plugins.sbt delete mode 100644 scripts/docs-build.sh delete mode 100644 scripts/docs-publish.sh delete mode 100755 scripts/travis-publish.sh delete mode 100644 search_index.json delete mode 100644 version.sbt diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml deleted file mode 100644 index 0d6ee5bd2..000000000 --- a/.github/workflows/ci.yml +++ /dev/null @@ -1,100 +0,0 @@ -# This file was automatically generated by sbt-github-actions using the -# githubWorkflowGenerate task. You should add and commit this file to -# your git repository. It goes without saying that you shouldn't edit -# this file by hand! Instead, if you wish to make changes, you should -# change your sbt build configuration to revise the workflow description -# to meet your needs, then regenerate this file. - -name: Continuous Integration - -on: - pull_request: - branches: ['*'] - push: - branches: ['*'] - -env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - -jobs: - build: - name: Build and Test - strategy: - matrix: - os: [ubuntu-latest] - scala: [2.12.12] - java: [adopt@1.8] - runs-on: ${{ matrix.os }} - steps: - - name: Checkout current branch (full) - uses: actions/checkout@v2 - with: - fetch-depth: 0 - - - name: Setup Java and Scala - uses: olafurpg/setup-scala@v10 - with: - java-version: ${{ matrix.java }} - - - name: Cache sbt - uses: actions/cache@v2 - with: - path: | - ~/.sbt - ~/.ivy2/cache - ~/.coursier/cache/v1 - ~/.cache/coursier/v1 - ~/AppData/Local/Coursier/Cache/v1 - ~/Library/Caches/Coursier/v1 - key: ${{ runner.os }}-sbt-cache-v2-${{ hashFiles('**/*.sbt') }}-${{ hashFiles('project/build.properties') }} - - - name: Check that workflows are up to date - run: sbt ++${{ matrix.scala }} githubWorkflowCheck - - - name: Setup Python - uses: actions/setup-python@v2 - with: - python-version: 3.x - - - name: Setup codecov - run: pip install codecov - - - name: Test & Compute Coverage - run: 'sbt ++${{ matrix.scala }} -Dfile.encoding=UTF8 -J-XX:ReservedCodeCacheSize=256M coverage test coverageReport' - - - name: Upload Codecov Results - run: codecov -F ${{ matrix.scala }} - - docs: - name: Documentation - strategy: - matrix: - os: [ubuntu-latest] - scala: [2.12.12] - java: [adopt@1.8] - runs-on: ${{ matrix.os }} - steps: - - name: Checkout current branch (full) - uses: actions/checkout@v2 - with: - fetch-depth: 0 - - - name: Setup Java and Scala - uses: olafurpg/setup-scala@v10 - with: - java-version: ${{ matrix.java }} - - - name: Cache sbt - uses: actions/cache@v2 - with: - path: | - ~/.sbt - ~/.ivy2/cache - ~/.coursier/cache/v1 - ~/.cache/coursier/v1 - ~/AppData/Local/Coursier/Cache/v1 - ~/Library/Caches/Coursier/v1 - key: ${{ runner.os }}-sbt-cache-v2-${{ hashFiles('**/*.sbt') }}-${{ hashFiles('project/build.properties') }} - - - name: Documentation - run: 'sbt ++${{ matrix.scala }} -Dfile.encoding=UTF8 -J-XX:ReservedCodeCacheSize=256M doc tut' \ No newline at end of file diff --git a/.github/workflows/clean.yml b/.github/workflows/clean.yml deleted file mode 100644 index b535fcc18..000000000 --- a/.github/workflows/clean.yml +++ /dev/null @@ -1,59 +0,0 @@ -# This file was automatically generated by sbt-github-actions using the -# githubWorkflowGenerate task. You should add and commit this file to -# your git repository. It goes without saying that you shouldn't edit -# this file by hand! Instead, if you wish to make changes, you should -# change your sbt build configuration to revise the workflow description -# to meet your needs, then regenerate this file. - -name: Clean - -on: push - -jobs: - delete-artifacts: - name: Delete Artifacts - runs-on: ubuntu-latest - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} - steps: - - name: Delete artifacts - run: | - # Customize those three lines with your repository and credentials: - REPO=${GITHUB_API_URL}/repos/${{ github.repository }} - - # A shortcut to call GitHub API. - ghapi() { curl --silent --location --user _:$GITHUB_TOKEN "$@"; } - - # A temporary file which receives HTTP response headers. - TMPFILE=/tmp/tmp.$$ - - # An associative array, key: artifact name, value: number of artifacts of that name. - declare -A ARTCOUNT - - # Process all artifacts on this repository, loop on returned "pages". - URL=$REPO/actions/artifacts - while [[ -n "$URL" ]]; do - - # Get current page, get response headers in a temporary file. - JSON=$(ghapi --dump-header $TMPFILE "$URL") - - # Get URL of next page. Will be empty if we are at the last page. - URL=$(grep '^Link:' "$TMPFILE" | tr ',' '\n' | grep 'rel="next"' | head -1 | sed -e 's/.*.*//') - rm -f $TMPFILE - - # Number of artifacts on this page: - COUNT=$(( $(jq <<<$JSON -r '.artifacts | length') )) - - # Loop on all artifacts on this page. - for ((i=0; $i < $COUNT; i++)); do - - # Get name of artifact and count instances of this name. - name=$(jq <<<$JSON -r ".artifacts[$i].name?") - ARTCOUNT[$name]=$(( $(( ${ARTCOUNT[$name]} )) + 1)) - - id=$(jq <<<$JSON -r ".artifacts[$i].id?") - size=$(( $(jq <<<$JSON -r ".artifacts[$i].size_in_bytes?") )) - printf "Deleting '%s' #%d, %'d bytes\n" $name ${ARTCOUNT[$name]} $size - ghapi -X DELETE $REPO/actions/artifacts/$id - done - done \ No newline at end of file diff --git a/.gitignore b/.gitignore deleted file mode 100644 index af472ae5b..000000000 --- a/.gitignore +++ /dev/null @@ -1,29 +0,0 @@ -*.class -*.log - -# sbt specific -.bsp/ -dist/* -target/ -lib_managed/ -src_managed/ -project/boot/ -project/plugins/project/ - -# Scala-IDE specific -.scala_dependencies -.cache -.classpath -.project -.worksheet/ -bin/ -.settings/ -.ensime -.ensime_cache/ - -# IntelliJ specific -.idea - -# OS X -.DS_Store -node_modules diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 000000000..e69de29bb diff --git a/Cats.html b/Cats.html index 7939062f5..24e9133d5 100644 --- a/Cats.html +++ b/Cats.html @@ -1,520 +1,257 @@ - - - - - - - Using Cats with RDDs · GitBook - - - - - - + + + + + + + + Using Cats with Frameless - - - - - - - - - - - - - - - - - - - + - - - + - + - + + + - + + - - - - - - - - - + - - - - - - +

                  - - +
                  + + + -
                  -
                  +
                  + + + + + + + + + +
                  + + + +
                  + +

                - - - - +

                Effect Suspension in typed datasets

                +

                As noted in the section about Job, all operations on TypedDataset are lazy. The results of + operations that would normally block on plain Spark APIs are wrapped in a type constructor F[_], + for which there exists an instance of SparkDelay[F]. This typeclass represents the operation of + delaying a computation and capturing an implicit SparkSession.

                +

                In the cats module, we utilize the typeclasses from cats-effect for abstracting over these + effect types - namely, we provide an implicit SparkDelay instance for all F[_] for which exists + an instance of cats.effect.Sync[F].

                +

                This allows one to run operations on TypedDataset in an existing monad stack. For example, given + this pre-existing monad stack:

                + 
                import frameless.TypedDataset
+import cats.data.ReaderT
+import cats.effect.IO
+import cats.effect.implicits._
+
+type Action[T] = ReaderT[IO, SparkSession, T]
                +

                We will be able to request that values from TypedDataset will be suspended in this stack:

                + 
                val typedDs = TypedDataset.create(Seq((1, "string"), (2, "another")))
+// typedDs: TypedDataset[(Int, String)] = [_1: int, _2: string]
+val result: Action[(Seq[(Int, String)], Long)] = for {
+  sample <- typedDs.take[Action](1)
+  count <- typedDs.count[Action]()
+} yield (sample, count)
+// result: Action[(Seq[(Int, String)], Long)] = Kleisli(
+//   cats.data.Kleisli$$$Lambda$13173/1148508813@3ef9fdf
+// )
                +

                As with Job, note that nothing has been run yet. The effect has been properly suspended. To + run our program, we must first supply the SparkSession to the ReaderT layer and then + run the IO effect:

                + 
                result.run(spark).unsafeRunSync()
+// res5: (Seq[(Int, String)], Long) = (WrappedArray((1, "string")), 2L)
                - - -
                - -
                - - - - - - - - -
                -
                - -
                -
                - -
                - -

                Using Cats with Frameless

                -

                There are two main parts to the cats integration offered by Frameless:

                -
                  -
                • effect suspension in TypedDataset using cats-effect and cats-mtl
                  • -
                • RDD enhancements using algebraic typeclasses in cats-kernel
                  • -
                -

                All the examples below assume you have previously imported cats.implicits and frameless.cats.implicits.

                -

                Note that you should not import frameless.syntax._ together with frameless.cats.implicits._.

                -
                import cats.implicits._
-// import cats.implicits._
-
-import frameless.cats.implicits._
-// import frameless.cats.implicits._
-
                -

                Effect Suspension in typed datasets

                -

                As noted in the section about Job, all operations on TypedDataset are lazy. The results of -operations that would normally block on plain Spark APIs are wrapped in a type constructor F[_], -for which there exists an instance of SparkDelay[F]. This typeclass represents the operation of -delaying a computation and capturing an implicit SparkSession.

                -

                In the cats module, we utilize the typeclasses from cats-effect for abstracting over these -effect types - namely, we provide an implicit SparkDelay instance for all F[_] for which exists -an instance of cats.effect.Sync[F].

                -

                This allows one to run operations on TypedDataset in an existing monad stack. For example, given -this pre-existing monad stack:

                -
                import frameless.TypedDataset
-// import frameless.TypedDataset
-
-import cats.data.ReaderT
-// import cats.data.ReaderT
-
-import cats.effect.IO
-// import cats.effect.IO
-
-import cats.effect.implicits._
-// import cats.effect.implicits._
-
-type Action[T] = ReaderT[IO, SparkSession, T]
-// defined type alias Action
-
                -

                We will be able to request that values from TypedDataset will be suspended in this stack:

                -
                val typedDs = TypedDataset.create(Seq((1, "string"), (2, "another")))
-// typedDs: frameless.TypedDataset[(Int, String)] = [_1: int, _2: string]
-
-val result: Action[(Seq[(Int, String)], Long)] = for {
-  sample <- typedDs.take[Action](1)
-  count <- typedDs.count[Action]()
-} yield (sample, count)
-// result: Action[(Seq[(Int, String)], Long)] = Kleisli(cats.data.Kleisli$$$Lambda$12127/0x0000000802d65040@27729265)
-
                -

                As with Job, note that nothing has been run yet. The effect has been properly suspended. To -run our program, we must first supply the SparkSession to the ReaderT layer and then -run the IO effect:

                -
                result.run(spark).unsafeRunSync()
-// res5: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)
-
                -

                Convenience methods for modifying Spark thread-local variables

                -

                The frameless.cats.implicits._ import also provides some syntax enrichments for any monad -stack that has the same capabilities as Action above. Namely, the ability to provide an -instance of SparkSession and the ability to suspend effects.

                -

                For these to work, we will need to import the implicit machinery from the cats-mtl library:

                -
                import cats.mtl.implicits._
-// import cats.mtl.implicits._
-
                -

                And now, we can set the description for the computation being run:

                -
                val resultWithDescription: Action[(Seq[(Int, String)], Long)] = for {
-  r <- result.withDescription("fancy cats")
-  session <- ReaderT.ask[IO, SparkSession]
-  _ <- ReaderT.liftF {
-         IO {
-           println(s"Description: ${session.sparkContext.getLocalProperty("spark.job.description")}")
+        
                Convenience methods for modifying Spark thread-local variables
                
+        
                The frameless.cats.implicits._ import also provides some syntax enrichments for any monad
+        stack that has the same capabilities as Action above. Namely, the ability to provide an
+        instance of SparkSession and the ability to suspend effects.
                
+        
                For these to work, we will need to import the implicit machinery from the cats-mtl library:
                
+        
                import cats.mtl.implicits._
                
+        
                And now, we can set the description for the computation being run:
                
+        
                val resultWithDescription: Action[(Seq[(Int, String)], Long)] = for {
+  r <- result.withDescription("fancy cats")
+  session <- ReaderT.ask[IO, SparkSession]
+  _ <- ReaderT.liftF {
+         IO {
+           println(s"Description: ${session.sparkContext.getLocalProperty("spark.job.description")}")
          }
        }
-} yield r
-// resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli(cats.data.Kleisli$$$Lambda$12127/0x0000000802d65040@252f71e5)
-
-resultWithDescription.run(spark).unsafeRunSync()
-// Description: fancy cats
-// res6: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)
-
                
-
                Using algebraic typeclasses from Cats with RDDs
                
-
                Data aggregation is one of the most important operations when working with Spark (and data in general).
-For example, we often have to compute the min, max, avg, etc. from a set of columns grouped by
-different predicates. This section shows how cats simplifies these tasks in Spark by
-leveraging a large collection of Type Classes for ordering and aggregating data.
                
-
                Cats offers ways to sort and aggregate tuples of arbitrary arity.
                
-
                import frameless.cats.implicits._
-// import frameless.cats.implicits._
-
-val data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)
-// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[12] at makeRDD at <console>:43
-
-println(data.csum)
-// (10,9,9)
-
-println(data.cmax)
-// (8,2,3)
-
-println(data.cmin)
-// (1,2,3)
-
                
-
                In case the RDD is empty, the csum, cmax and cmin will use the default values for the type of
-elements inside the RDD. There are counterpart operations to those that have an Option return type
-to deal with the case of an empty RDD:
                
-
                val data: RDD[(Int, Int, Int)] = sc.emptyRDD
-// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = EmptyRDD[13] at emptyRDD at <console>:43
-
-println(data.csum)
-// (0,0,0)
-
-println(data.csumOption)
-// None
-
-println(data.cmax)
-// (0,0,0)
-
-println(data.cmaxOption)
-// None
-
-println(data.cmin)
-// (0,0,0)
-
-println(data.cminOption)
-// None
-
                
-
                The following example aggregates all the elements with a common key.
                
-
                type User = String
-// defined type alias User
-
-type TransactionCount = Int
-// defined type alias TransactionCount
-
-val allData: RDD[(User,TransactionCount)] =
-   sc.makeRDD(("Bob", 12) :: ("Joe", 1) :: ("Anna", 100) :: ("Bob", 20) :: ("Joe", 2) :: Nil)
-// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[14] at makeRDD at <console>:46
-
-val totalPerUser =  allData.csumByKey
-// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[15] at reduceByKey at implicits.scala:42
-
-totalPerUser.collectAsMap
-// res16: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)
-
                
-
                The same example would work for more complex keys.
                
-
                import scala.collection.immutable.SortedMap
-// import scala.collection.immutable.SortedMap
-
-val allDataComplexKeu =
-   sc.makeRDD( ("Bob", SortedMap("task1" -> 10)) ::
-    ("Joe", SortedMap("task1" -> 1, "task2" -> 3)) :: ("Bob", SortedMap("task1" -> 10, "task2" -> 1)) :: ("Joe", SortedMap("task3" -> 4)) :: Nil )
-// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ParallelCollectionRDD[16] at makeRDD at <console>:45
-
-val overalTasksPerUser = allDataComplexKeu.csumByKey
-// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ShuffledRDD[17] at reduceByKey at implicits.scala:42
-
-overalTasksPerUser.collectAsMap
-// res17: scala.collection.Map[String,scala.collection.immutable.SortedMap[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))
-
                
-
                Joins
                
-
                // Type aliases for meaningful types
-type TimeSeries = Map[Int,Int]
-// defined type alias TimeSeries
-
-type UserName = String
-// defined type alias UserName
-
                
-
                Example: Using the implicit full-our-join operator
                
-
                import frameless.cats.outer._
-// import frameless.cats.outer._
-
-val day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 2, 1 -> 4)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Sam", Map(0 -> 1)) :: Nil )
-// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[18] at makeRDD at <console>:49
-
-val day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 10, 1 -> 11)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Joe", Map(0 -> 1, 1 -> 2)) :: Nil )
-// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[19] at makeRDD at <console>:49
-
-val daysCombined = day1 |+| day2
-// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[23] at mapValues at implicits.scala:67
-
-daysCombined.collect()
-// res19: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))
-
                
-
                Note how the user's timeseries from different days have been aggregated together.
-The |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join
-on the key and combine values using the default Semigroup for the value type.
                
-
                In cats:
                
-
                Map(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)
-// res20: scala.collection.immutable.Map[Int,Int] = Map(1 -> 6, 2 -> 2)
-
                
-
-                                
-
                - -
                -
                -
                - -

                results matching ""

                -
                  - -
                  -
                  - -

                  No results matching ""

                  - -
                  -
                  -
                  - -
                  -
                  - -
                  - - - - - - - - - - - - - +} yield r +// resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( +// cats.data.Kleisli$$$Lambda$13173/1148508813@68e35367 +// ) + +resultWithDescription.run(spark).unsafeRunSync() +// Description: fancy cats +// res6: (Seq[(Int, String)], Long) = (WrappedArray((1, "string")), 2L) -
                  - - - - - - - - - - - - +

                  Using algebraic typeclasses from Cats with RDDs

                  +

                  Data aggregation is one of the most important operations when working with Spark (and data in general). + For example, we often have to compute the min, max, avg, etc. from a set of columns grouped by + different predicates. This section shows how cats simplifies these tasks in Spark by + leveraging a large collection of Type Classes for ordering and aggregating data.

                  +

                  Cats offers ways to sort and aggregate tuples of arbitrary arity.

                  + 
                  import frameless.cats.implicits._
+
+val data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)
+// data: RDD[(Int, Int, Int)] = ParallelCollectionRDD[12] at makeRDD at Cats.md:127
+
+println(data.csum)
+// (10,9,9)
+println(data.cmax)
+// (8,2,3)
+println(data.cmin)
+// (1,2,3)
                  +

                  In case the RDD is empty, the csum, cmax and cmin will use the default values for the type of + elements inside the RDD. There are counterpart operations to those that have an Option return type + to deal with the case of an empty RDD:

                  + 
                  val data: RDD[(Int, Int, Int)] = sc.emptyRDD
+// data: RDD[(Int, Int, Int)] = EmptyRDD[13] at emptyRDD at Cats.md:143
+
+println(data.csum)
+// (0,0,0)
+println(data.csumOption)
+// None
+println(data.cmax)
+// (0,0,0)
+println(data.cmaxOption)
+// None
+println(data.cmin)
+// (0,0,0)
+println(data.cminOption)
+// None
                  +

                  The following example aggregates all the elements with a common key.

                  + 
                  type User = String
+type TransactionCount = Int
+
+val allData: RDD[(User,TransactionCount)] =
+   sc.makeRDD(("Bob", 12) :: ("Joe", 1) :: ("Anna", 100) :: ("Bob", 20) :: ("Joe", 2) :: Nil)
+// allData: RDD[(User, TransactionCount)] = ParallelCollectionRDD[14] at makeRDD at Cats.md:174
+
+val totalPerUser =  allData.csumByKey
+// totalPerUser: RDD[(User, TransactionCount)] = ShuffledRDD[15] at reduceByKey at implicits.scala:42
+
+totalPerUser.collectAsMap
+// res16: collection.Map[User, TransactionCount] = Map(
+//   "Bob" -> 32,
+//   "Joe" -> 3,
+//   "Anna" -> 100
+// )
                  +

                  The same example would work for more complex keys.

                  + 
                  import scala.collection.immutable.SortedMap
+
+val allDataComplexKeu =
+   sc.makeRDD( ("Bob", SortedMap("task1" -> 10)) ::
+    ("Joe", SortedMap("task1" -> 1, "task2" -> 3)) :: ("Bob", SortedMap("task1" -> 10, "task2" -> 1)) :: ("Joe", SortedMap("task3" -> 4)) :: Nil )
+// allDataComplexKeu: RDD[(String, SortedMap[String, Int])] = ParallelCollectionRDD[16] at makeRDD at Cats.md:190
+
+val overalTasksPerUser = allDataComplexKeu.csumByKey
+// overalTasksPerUser: RDD[(String, SortedMap[String, Int])] = ShuffledRDD[17] at reduceByKey at implicits.scala:42
+
+overalTasksPerUser.collectAsMap
+// res17: collection.Map[String, SortedMap[String, Int]] = Map(
+//   "Bob" -> Map("task1" -> 20, "task2" -> 1),
+//   "Joe" -> Map("task1" -> 1, "task2" -> 3, "task3" -> 4)
+// )
                  - - - - - - - - - - - - - - - - - - - +

                  Joins

                  + 
                  // Type aliases for meaningful types
+type TimeSeries = Map[Int,Int]
+type UserName = String
                  +

                  Example: Using the implicit full-our-join operator

                  + 
                  import frameless.cats.outer._
+
+val day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 2, 1 -> 4)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Sam", Map(0 -> 1)) :: Nil )
+// day1: RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[18] at makeRDD at Cats.md:215
+val day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 10, 1 -> 11)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Joe", Map(0 -> 1, 1 -> 2)) :: Nil )
+// day2: RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[19] at makeRDD at Cats.md:218
+
+val daysCombined = day1 |+| day2
+// daysCombined: RDD[(UserName, TimeSeries)] = MapPartitionsRDD[23] at mapValues at implicits.scala:67
+
+daysCombined.collect()
+// res18: Array[(UserName, TimeSeries)] = Array(
+//   ("Joe", Map(0 -> 1, 1 -> 2)),
+//   ("Sam", Map(0 -> 1)),
+//   ("Chris", Map(0 -> 2, 1 -> 4)),
+//   ("John", Map(0 -> 12, 1 -> 15))
+// )
                  +

                  Note how the user's timeseries from different days have been aggregated together. + The |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join + on the key and combine values using the default Semigroup for the value type.

                  +

                  In cats:

                  + 
                  Map(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)
+// res19: Map[Int, Int] = Map(1 -> 6, 2 -> 2)
                  + + - - + + + \ No newline at end of file diff --git a/FeatureOverview.html b/FeatureOverview.html index 80d86535d..d2b6de0a0 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -1,1208 +1,888 @@ - - - - - - - TypedDataset: Feature Overview · GitBook - - - - - - + + + + + + + + TypedDataset: Feature Overview - - - - - - - - - - - - - - - - - + - - - - - + - + - + + + - + + - - - - - - - - - + - - - - - - +
                  - - +
                  + + + -
                  -
                  +
                  + + + + + + + + + +
                  + + + +

                  • - -
                • - - - - - TypedDataset: Feature Overview - - - - - -
                  • - -
                • - - - - - Comparing TypedDatasets with Spark's Datasets - - - - - -
                  • - -
                • - - - - - Typed Encoders in Frameless - - - - - -
                  • - -
                • - - - - - Injection: Creating Custom Encoders - - - - - -
                  • - -
                • - - - - - Job[A] - - - - - -
                  • - -
                • - - - - - Using Cats with RDDs - - - - - -
                  • - -
                • - - - - - Using Spark ML with TypedDataset - - - - - -
                  • - -
                • - - - - - Proof of Concept: TypedDataFrame - - - - - -
                  • - +
                  - - -
                • +

                  TypedDataset: Feature Overview

                  +

                  This tutorial introduces TypedDataset using a simple example. + The following imports are needed to make all code examples compile.

                  + 
                  import org.apache.spark.{SparkConf, SparkContext}
+import org.apache.spark.sql.SparkSession
+import frameless.functions.aggregate._
+import frameless.TypedDataset
 
-    
                • 
-        
-            Published with GitBook
-        
-    
                  • 
-
+                  val conf = new SparkConf().setMaster("local[*]").setAppName("Frameless repl").set("spark.ui.enabled", "false")
+implicit val spark = SparkSession.builder().config(conf).appName("REPL").getOrCreate()
+spark.sparkContext.setLogLevel("WARN")
 
-
-                
-            
+import spark.implicits._
                  - - -
                  +

                  Creating TypedDataset instances

                  +

                  We start by defining a case class:

                  + 
                  case class Apartment(city: String, surface: Int, price: Double, bedrooms: Int)
                  +

                  And few Apartment instances:

                  + 
                  val apartments = Seq(
+  Apartment("Paris", 50,  300000.0, 2),
+  Apartment("Paris", 100, 450000.0, 3),
+  Apartment("Paris", 25,  250000.0, 1),
+  Apartment("Lyon",  83,  200000.0, 2),
+  Apartment("Lyon",  45,  133000.0, 1),
+  Apartment("Nice",  74,  325000.0, 3)
+)
                  +

                  We are now ready to instantiate a TypedDataset[Apartment]:

                  + 
                  val aptTypedDs = TypedDataset.create(apartments)
+// aptTypedDs: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
                  +

                  We can also create one from an existing Spark Dataset:

                  + 
                  val aptDs = spark.createDataset(apartments)
+// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 2 more fields]
+val aptTypedDs = TypedDataset.create(aptDs)
+// aptTypedDs: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
                  +

                  Or use the Frameless syntax:

                  + 
                  import frameless.syntax._
+
+val aptTypedDs2 = aptDs.typed
+// aptTypedDs2: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
                  -
                  - - - - - - - - -
                  -
                  - -
                  -
                  - -
                  - -

                  TypedDataset: Feature Overview

                  -

                  This tutorial introduces TypedDataset using a simple example. -The following imports are needed to make all code examples compile.

                  -
                  import org.apache.spark.{SparkConf, SparkContext}
-import org.apache.spark.sql.SparkSession
-import frameless.functions.aggregate._
-import frameless.TypedDataset
-
-val conf = new SparkConf().setMaster("local[*]").setAppName("Frameless repl").set("spark.ui.enabled", "false")
-implicit val spark = SparkSession.builder().config(conf).appName("REPL").getOrCreate()
-spark.sparkContext.setLogLevel("WARN")
-
-import spark.implicits._
-
                  -

                  Creating TypedDataset instances

                  -

                  We start by defining a case class:

                  -
                  case class Apartment(city: String, surface: Int, price: Double, bedrooms: Int)
-
                  -

                  And few Apartment instances:

                  -
                  val apartments = Seq(
-  Apartment("Paris", 50,  300000.0, 2),
-  Apartment("Paris", 100, 450000.0, 3),
-  Apartment("Paris", 25,  250000.0, 1),
-  Apartment("Lyon",  83,  200000.0, 2),
-  Apartment("Lyon",  45,  133000.0, 1),
-  Apartment("Nice",  74,  325000.0, 3)
-)
-
                  -

                  We are now ready to instantiate a TypedDataset[Apartment]:

                  -
                  val aptTypedDs = TypedDataset.create(apartments)
-// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
-
                  -

                  We can also create one from an existing Spark Dataset:

                  -
                  val aptDs = spark.createDataset(apartments)
-// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 2 more fields]
-
-val aptTypedDs = TypedDataset.create(aptDs)
-// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
-
                  -

                  Or use the Frameless syntax:

                  -
                  import frameless.syntax._
-// import frameless.syntax._
-
-val aptTypedDs2 = aptDs.typed
-// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
-
                  -

                  Typesafe column referencing

                  -

                  This is how we select a particular column from a TypedDataset:

                  -
                  val cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))
-// cities: frameless.TypedDataset[String] = [value: string]
-
                  -

                  This is completely type-safe, for instance suppose we misspell city as citi:

                  -
                  aptTypedDs.select(aptTypedDs('citi))
-// <console>:27: error: No column Symbol with shapeless.tag.Tagged[String("citi")] of type A in Apartment
-//        aptTypedDs.select(aptTypedDs('citi))
-//                                    ^
-
                  -

                  This gets raised at compile time, whereas with the standard Dataset API the error appears at runtime (enjoy the stack trace):

                  -
                  aptDs.select('citi)
-// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [bedrooms, city, price, surface];
-// 'Project ['citi]
-// +- LocalRelation [city#1384, surface#1385, price#1386, bedrooms#1387]
-// 
-//   at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:155)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:152)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode.$anonfun$transformUp$2(TreeNode.scala:341)
-//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:341)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$transformExpressionsUp$1(QueryPlan.scala:104)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$1(QueryPlan.scala:116)
-//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:116)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:127)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$3(QueryPlan.scala:132)
-//   at scala.collection.TraversableLike.$anonfun$map$1(TraversableLike.scala:285)
-//   at scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)
-//   at scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)
-//   at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)
-//   at scala.collection.TraversableLike.map(TraversableLike.scala:285)
-//   at scala.collection.TraversableLike.map$(TraversableLike.scala:278)
-//   at scala.collection.AbstractTraversable.map(Traversable.scala:108)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:132)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$4(QueryPlan.scala:137)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:243)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:137)
-//   at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:104)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1(CheckAnalysis.scala:152)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1$adapted(CheckAnalysis.scala:93)
-//   at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:183)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:93)
-//   at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:90)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:154)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:175)
-//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)
-//   at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)
-//   at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)
-//   at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)
-//   at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)
-//   at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)
-//   at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)
-//   at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)
-//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)
-//   at org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:90)
-//   at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)
-//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:88)
-//   at org.apache.spark.sql.Dataset.withPlan(Dataset.scala:3715)
-//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1462)
-//   ... 42 elided
-
                  -

                  select() supports arbitrary column operations:

                  -
                  aptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()
-// +----+---+
-// |  _1| _2|
-// +----+---+
-// | 500| 52|
-// |1000|102|
-// | 250| 27|
-// | 830| 85|
-// | 450| 47|
-// | 740| 76|
-// +----+---+
-//
-
                  -

                  Note that unlike the standard Spark API, where some operations are lazy and some are not, all TypedDatasets operations are lazy. -In the above example, show() is lazy. It requires to apply run() for the show job to materialize. -A more detailed explanation of Job is given here.

                  -

                  Next we compute the price by surface unit:

                  -
                  val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))
-// <console>:26: error: overloaded method value / with alternatives:
-//   (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] <and>
-//   [Out, TT, W](other: frameless.TypedColumn[TT,Double])(implicit n: frameless.CatalystDivisible[Double,Out], implicit e: frameless.TypedEncoder[Out], implicit w: frameless.With[Apartment,TT]{type Out = W})frameless.TypedColumn[W,Out]
-//  cannot be applied to (frameless.TypedColumn[Apartment,Int])
-//        val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))
-//                                                                      ^
-
                  -

                  As the error suggests, we can't divide a TypedColumn of Double by Int. -For safety, in Frameless only math operations between same types is allowed:

                  -
                  val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])
-// priceBySurfaceUnit: frameless.TypedDataset[Double] = [value: double]
-
-priceBySurfaceUnit.collect().run()
-// res4: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)
-
                  -

                  Looks like it worked, but that cast seems unsafe right? Actually it is safe. -Let's try to cast a TypedColumn of String to Double:

                  -
                  aptTypedDs('city).cast[Double]
-// <console>:27: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]
-//        aptTypedDs('city).cast[Double]
-//                              ^
-
                  -

                  The compile-time error tells us that to perform the cast, an evidence -(in the form of CatalystCast[String, Double]) must be available. -Since casting from String to Double is not allowed, this results -in a compilation error.

                  -

                  Check here -for the set of available CatalystCast.

                  -

                  Working with Optional columns

                  -

                  When working with real data we have to deal with imperfections, such as missing fields. Columns that may have -missing data should be represented using Options. For this example, let's assume that the Apartments dataset -may have missing values.

                  -
                  case class ApartmentOpt(city: Option[String], surface: Option[Int], price: Option[Double], bedrooms: Option[Int])
-
                  -
                  val apartmentsOpt = Seq(
-  ApartmentOpt(Some("Paris"), Some(50),  Some(300000.0), None),
-  ApartmentOpt(None, None, Some(450000.0), Some(3))
-)
-
                  -
                  val aptTypedDsOpt = TypedDataset.create(apartmentsOpt)
-// aptTypedDsOpt: frameless.TypedDataset[ApartmentOpt] = [city: string, surface: int ... 2 more fields]
-
-aptTypedDsOpt.show().run()
-// +-----+-------+--------+--------+
-// | city|surface|   price|bedrooms|
-// +-----+-------+--------+--------+
-// |Paris|     50|300000.0|    null|
-// | null|   null|450000.0|       3|
-// +-----+-------+--------+--------+
-//
-
                  -

                  Unfortunately the syntax used above with select() will not work here:

                  -
                  aptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()
-// <console>:27: error: overloaded method value * with alternatives:
-//   (u: Option[Int])(implicit n: frameless.CatalystNumeric[Option[Int]])frameless.TypedColumn[ApartmentOpt,Option[Int]] <and>
-//   [TT, W](other: frameless.TypedColumn[TT,Option[Int]])(implicit n: frameless.CatalystNumeric[Option[Int]], implicit w: frameless.With[ApartmentOpt,TT]{type Out = W}, implicit t: scala.reflect.ClassTag[Option[Int]])frameless.TypedColumn[W,Option[Int]]
-//  cannot be applied to (Int)
-//        aptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()
-//                                                     ^
-// <console>:27: error: overloaded method value + with alternatives:
-//   (u: Option[Int])(implicit n: frameless.CatalystNumeric[Option[Int]])frameless.TypedColumn[ApartmentOpt,Option[Int]] <and>
-//   [TT, W](other: frameless.TypedColumn[TT,Option[Int]])(implicit n: frameless.CatalystNumeric[Option[Int]], implicit w: frameless.With[ApartmentOpt,TT]{type Out = W})frameless.TypedColumn[W,Option[Int]]
-//  cannot be applied to (Int)
-//        aptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()
-//                                                                                   ^
-
                  -

                  This is because we cannot multiple an Option with an Int. In Scala, Option has a map() method to help address -exactly this (e.g., Some(10).map(c => c * 2)). Frameless follows a similar convention. By applying the opt method on -any Option[X] column you can then use map() to provide a function that works with the unwrapped type X. -This is best shown in the example bellow:

                  -
                  scala>  aptTypedDsOpt.select(aptTypedDsOpt('surface).opt.map(c => c * 10), aptTypedDsOpt('surface).opt.map(_ + 2)).show().run()
-+----+----+
-|  _1|  _2|
-+----+----+
-| 500|  52|
-|null|null|
-+----+----+
-
                  -

                  Known issue: map() will throw a runtime exception when the applied function includes a udf(). If you want to -apply a udf() to an optional column, we recommend changing your udf to work directly with Optional fields.

                  -

                  Casting and projections

                  -

                  In the general case, select() returns a TypedDataset of type TypedDataset[TupleN[...]] (with N in [1...10]). -For example, if we select three columns with types String, Int, and Boolean the result will have type -TypedDataset[(String, Int, Boolean)].

                  -

                  We often want to give more expressive types to the result of our computations. -as[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long -as the types in U and T align.

                  -

                  When the cast is valid the expression compiles:

                  -
                  case class UpdatedSurface(city: String, surface: Int)
-// defined class UpdatedSurface
-
-val updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]
-// updated: frameless.TypedDataset[UpdatedSurface] = [city: string, surface: int]
-
-updated.show(2).run()
-// +-----+-------+
-// | city|surface|
-// +-----+-------+
-// |Paris|     52|
-// |Paris|    102|
-// +-----+-------+
-// only showing top 2 rows
-//
-
                  -

                  Next we try to cast a (String, String) to an UpdatedSurface (which has types String, Int). -The cast is not valid and the expression does not compile:

                  -
                  aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]
-// <console>:29: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]
-//        aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]
-//                                                                  ^
-
                  -

                  Advanced topics with select()

                  -

                  When you select() a single column that has type A, the resulting type is TypedDataset[A] and -not TypedDataset[Tuple1[A]]. This behavior makes working with nested schema easier (i.e., in the case -where A is a complex data type) and simplifies type-checking column operations (e.g., verify that two -columns can be added, divided, etc.). However, when A is scalar, say a Long, it makes it harder to select -and work with the resulting TypedDataset[Long]. For instance, it's harder to reference this single scalar -column using select(). If this becomes an issue, you can bypass this behavior by using the -selectMany() method instead of select(). In the previous example, selectMany() will return -TypedDataset[Tuple1[Long]] and you can reference its single column using the name _1. -selectMany() should also be used when you need to select more than 10 columns. -select() has better IDE support and compiles faster than the macro based selectMany(), -so prefer select() for the most common use cases.

                  -

                  When you are handed a single scalar column TypedDataset (e.g., TypedDataset[Double]) -the best way to reference its single column is using the asCol (short for "as a column") method. -This is best shown in the example below. We will see more usages of asCol later in this tutorial.

                  -
                  val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])
-// priceBySurfaceUnit: frameless.TypedDataset[Double] = [value: double]
-
-priceBySurfaceUnit.select(priceBySurfaceUnit.asCol * 2).show(2).run()
-// +-------+
-// |  value|
-// +-------+
-// |12000.0|
-// | 9000.0|
-// +-------+
-// only showing top 2 rows
-//
-
                  -

                  Projections

                  -

                  We often want to work with a subset of the fields in a dataset. -Projections allow us to easily select our fields of interest -while preserving their initial names and types for extra safety.

                  -

                  Here is an example using the TypedDataset[Apartment] with an additional column:

                  -
                  val aptds = aptTypedDs // For shorter expressions
-// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
-
-case class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)
-// defined class ApartmentDetails
-
-val aptWithRatio =
-  aptds.select(
-    aptds('city),
-    aptds('price),
-    aptds('surface),
-    aptds('price) / aptds('surface).cast[Double]
-  ).as[ApartmentDetails]
-// aptWithRatio: frameless.TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]
-
                  -

                  Suppose we only want to work with city and ratio:

                  -
                  case class CityInfo(city: String, ratio: Double)
-// defined class CityInfo
-
-val cityRatio = aptWithRatio.project[CityInfo]
-// cityRatio: frameless.TypedDataset[CityInfo] = [city: string, ratio: double]
-
-cityRatio.show(2).run()
-// +-----+------+
-// | city| ratio|
-// +-----+------+
-// |Paris|6000.0|
-// |Paris|4500.0|
-// +-----+------+
-// only showing top 2 rows
-//
-
                  -

                  Suppose we only want to work with price and ratio:

                  -
                  case class PriceInfo(ratio: Double, price: Double)
-// defined class PriceInfo
-
-val priceInfo = aptWithRatio.project[PriceInfo]
-// priceInfo: frameless.TypedDataset[PriceInfo] = [ratio: double, price: double]
-
-priceInfo.show(2).run()
-// +------+--------+
-// | ratio|   price|
-// +------+--------+
-// |6000.0|300000.0|
-// |4500.0|450000.0|
-// +------+--------+
-// only showing top 2 rows
-//
-
                  -

                  We see that the order of the fields does not matter as long as the -names and the corresponding types agree. However, if we make a mistake in -any of the names and/or their types, then we get a compilation error.

                  -

                  Say we make a typo in a field name:

                  -
                  case class PriceInfo2(ratio: Double, pricEE: Double)
-
                  -
                  aptWithRatio.project[PriceInfo2]
-// <console>:29: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?
-//        aptWithRatio.project[PriceInfo2]
-//                            ^
-
                  -

                  Say we make a mistake in the corresponding type:

                  -
                  case class PriceInfo3(ratio: Int, price: Double) // ratio should be Double
-
                  -
                  aptWithRatio.project[PriceInfo3]
-// <console>:29: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?
-//        aptWithRatio.project[PriceInfo3]
-//                            ^
-
                  -

                  Union of TypedDatasets

                  -

                  Lets create a projection of our original dataset with a subset of the fields.

                  -
                  case class ApartmentShortInfo(city: String, price: Double, bedrooms: Int)
-
-val aptTypedDs2: TypedDataset[ApartmentShortInfo] = aptTypedDs.project[ApartmentShortInfo]
-
                  -

                  The union of aptTypedDs2 with aptTypedDs uses all the fields of the caller (aptTypedDs2) -and expects the other dataset (aptTypedDs) to include all those fields. -If field names/types do not match you get a compilation error.

                  -
                  aptTypedDs2.union(aptTypedDs).show().run
-// +-----+--------+--------+
-// | city|   price|bedrooms|
-// +-----+--------+--------+
-// |Paris|300000.0|       2|
-// |Paris|450000.0|       3|
-// |Paris|250000.0|       1|
-// | Lyon|200000.0|       2|
-// | Lyon|133000.0|       1|
-// | Nice|325000.0|       3|
-// |Paris|300000.0|       2|
-// |Paris|450000.0|       3|
-// |Paris|250000.0|       1|
-// | Lyon|200000.0|       2|
-// | Lyon|133000.0|       1|
-// | Nice|325000.0|       3|
-// +-----+--------+--------+
-//
-
                  -

                  The other way around will not compile, since aptTypedDs2 has only a subset of the fields.

                  -
                  aptTypedDs.union(aptTypedDs2).show().run
-// <console>:28: error: Cannot prove that ApartmentShortInfo can be projected to Apartment. Perhaps not all member names and types of Apartment are the same in ApartmentShortInfo?
-//        aptTypedDs.union(aptTypedDs2).show().run
-//                        ^
-
                  -

                  Finally, as with project, union will align fields that have same names/types, -so fields do not have to be in the same order.

                  -

                  TypedDataset functions and transformations

                  -

                  Frameless supports many of Spark's functions and transformations. -However, whenever a Spark function does not exist in Frameless, -calling .dataset will expose the underlying -Dataset (from org.apache.spark.sql, the original Spark APIs), -where you can use anything that would be missing from the Frameless' API.

                  -

                  These are the main imports for Frameless' aggregate and non-aggregate functions.

                  -
                  import frameless.functions._                // For literals
-import frameless.functions.nonAggregate._   // e.g., concat, abs
-import frameless.functions.aggregate._      // e.g., count, sum, avg
-
                  -

                  Drop/Replace/Add fields

                  -

                  dropTupled() drops a single column and results in a tuple-based schema.

                  -
                  aptTypedDs2.dropTupled('price): TypedDataset[(String,Int)]
-// res18: frameless.TypedDataset[(String, Int)] = [_1: string, _2: int]
-
                  -

                  To drop a column and specify a new schema use drop().

                  -
                  case class CityBeds(city: String, bedrooms: Int)
-// defined class CityBeds
-
-val cityBeds: TypedDataset[CityBeds] = aptTypedDs2.drop[CityBeds] 
-// cityBeds: frameless.TypedDataset[CityBeds] = [city: string, bedrooms: int]
-
                  -

                  Often, you want to replace an existing column with a new value.

                  -
                  val inflation = aptTypedDs2.withColumnReplaced('price, aptTypedDs2('price) * 2)
-// inflation: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]
-
-inflation.show(2).run()
-// +-----+--------+--------+
-// | city|   price|bedrooms|
-// +-----+--------+--------+
-// |Paris|600000.0|       2|
-// |Paris|900000.0|       3|
-// +-----+--------+--------+
-// only showing top 2 rows
-//
-
                  -

                  Or use a literal instead.

                  -
                  import frameless.functions.lit
-// import frameless.functions.lit
-
-aptTypedDs2.withColumnReplaced('price, lit(0.001)) 
-// res20: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]
-
                  -

                  Adding a column using withColumnTupled() results in a tupled-based schema.

                  -
                  aptTypedDs2.withColumnTupled(lit(Array("a","b","c"))).show(2).run()
-// +-----+--------+---+---------+
-// |   _1|      _2| _3|       _4|
-// +-----+--------+---+---------+
-// |Paris|300000.0|  2|[a, b, c]|
-// |Paris|450000.0|  3|[a, b, c]|
-// +-----+--------+---+---------+
-// only showing top 2 rows
-//
-
                  -

                  Similarly, withColumn() adds a column and explicitly expects a schema for the result.

                  -
                  case class CityBedsOther(city: String, bedrooms: Int, other: List[String])
-// defined class CityBedsOther
-
-cityBeds.
-   withColumn[CityBedsOther](lit(List("a","b","c"))).
-   show(1).run()
-// +-----+--------+---------+
-// | city|bedrooms|    other|
-// +-----+--------+---------+
-// |Paris|       2|[a, b, c]|
-// +-----+--------+---------+
-// only showing top 1 row
-//
-
                  -

                  To conditionally change a column use the when/otherwise operation.

                  -
                  import frameless.functions.nonAggregate.when
-// import frameless.functions.nonAggregate.when
-
-aptTypedDs2.withColumnTupled(
-   when(aptTypedDs2('city) === "Paris", aptTypedDs2('price)).
-   when(aptTypedDs2('city) === "Lyon", lit(1.1)).
-   otherwise(lit(0.0))).show(8).run()
-// +-----+--------+---+--------+
-// |   _1|      _2| _3|      _4|
-// +-----+--------+---+--------+
-// |Paris|300000.0|  2|300000.0|
-// |Paris|450000.0|  3|450000.0|
-// |Paris|250000.0|  1|250000.0|
-// | Lyon|200000.0|  2|     1.1|
-// | Lyon|133000.0|  1|     1.1|
-// | Nice|325000.0|  3|     0.0|
-// +-----+--------+---+--------+
-//
-
                  -

                  A simple way to add a column without losing important schema information is -to project the entire source schema into a single column using the asCol() method.

                  -
                  val c = cityBeds.select(cityBeds.asCol, lit(List("a","b","c")))
-// c: frameless.TypedDataset[(CityBeds, List[String])] = [_1: struct<city: string, bedrooms: int>, _2: array<string>]
-
-c.show(1).run()
-// +----------+---------+
-// |        _1|       _2|
-// +----------+---------+
-// |{Paris, 2}|[a, b, c]|
-// +----------+---------+
-// only showing top 1 row
-//
-
                  -

                  When working with Spark's DataFrames, you often select all columns using .select($"*", ...). -In a way, asCol() is a typed equivalent of $"*".

                  -

                  To access nested columns, use the colMany() method.

                  -
                  c.select(c.colMany('_1, 'city), c('_2)).show(2).run()
-// +-----+---------+
-// |   _1|       _2|
-// +-----+---------+
-// |Paris|[a, b, c]|
-// |Paris|[a, b, c]|
-// +-----+---------+
-// only showing top 2 rows
-//
-
                  -

                  Working with collections

                  -
                  import frameless.functions._
-// import frameless.functions._
-
-import frameless.functions.nonAggregate._
-// import frameless.functions.nonAggregate._
-
                  -
                  val t = cityRatio.select(cityRatio('city), lit(List("abc","c","d")))
-// t: frameless.TypedDataset[(String, List[String])] = [_1: string, _2: array<string>]
-
-t.withColumnTupled(
-   arrayContains(t('_2), "abc")
-).show(1).run()
-// +-----+-----------+----+
-// |   _1|         _2|  _3|
-// +-----+-----------+----+
-// |Paris|[abc, c, d]|true|
-// +-----+-----------+----+
-// only showing top 1 row
-//
-
                  -

                  If accidentally you apply a collection function on a column that is not a collection, -you get a compilation error.

                  -
                  t.withColumnTupled(
-   arrayContains(t('_1), "abc")
-)
-// <console>:36: error: no type parameters for method arrayContains: (column: frameless.AbstractTypedColumn[T,C[A]], value: A)(implicit evidence$1: frameless.CatalystCollection[C])column.ThisType[T,Boolean] exist so that it can be applied to arguments (frameless.TypedColumn[(String, List[String]),String], String)
-//  --- because ---
-// argument expression's type is not compatible with formal parameter type;
-//  found   : frameless.TypedColumn[(String, List[String]),String]
-//  required: frameless.AbstractTypedColumn[?T,?C[?A]]
-// 
-//           arrayContains(t('_1), "abc")
-//           ^
-// <console>:36: error: type mismatch;
-//  found   : frameless.TypedColumn[(String, List[String]),String]
-//  required: frameless.AbstractTypedColumn[T,C[A]]
-//           arrayContains(t('_1), "abc")
-//                          ^
-// <console>:36: error: type mismatch;
-//  found   : String("abc")
-//  required: A
-//           arrayContains(t('_1), "abc")
-//                                 ^
-// <console>:36: error: Cannot do collection operations on columns of type C.
-//           arrayContains(t('_1), "abc")
-//                        ^
-
                  -

                  Flattening columns in Spark is done with the explode() method. Unlike vanilla Spark, -in Frameless explode() is part of TypedDataset and not a function of a column. -This provides additional safety since more than one explode() applied in a single -statement results in runtime error in vanilla Spark.

                  -
                  val t2 = cityRatio.select(cityRatio('city), lit(List(1,2,3,4)))
-// t2: frameless.TypedDataset[(String, List[Int])] = [_1: string, _2: array<int>]
-
-val flattened = t2.explode('_2): TypedDataset[(String, Int)]
-// flattened: frameless.TypedDataset[(String, Int)] = [_1: string, _2: int]
-
-flattened.show(4).run()
-// +-----+---+
-// |   _1| _2|
-// +-----+---+
-// |Paris|  1|
-// |Paris|  2|
-// |Paris|  3|
-// |Paris|  4|
-// +-----+---+
-// only showing top 4 rows
-//
-
                  -

                  Here is an example of how explode() may fail in vanilla Spark. The Frameless -implementation does not suffer from this problem since, by design, it can only be applied -to a single column at a time.

                  -
                  {
-  import org.apache.spark.sql.functions.{explode => sparkExplode}
-  t2.dataset.toDF().select(sparkExplode($"_2"), sparkExplode($"_2"))
-}
-// org.apache.spark.sql.AnalysisException: Only one generator allowed per select clause but found 2: explode(_2), explode(_2)
-//   at org.apache.spark.sql.errors.QueryCompilationErrors$.moreThanOneGeneratorError(QueryCompilationErrors.scala:95)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$$anonfun$apply$22.applyOrElse(Analyzer.scala:2510)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$$anonfun$apply$22.applyOrElse(Analyzer.scala:2503)
-//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.$anonfun$resolveOperatorsUp$3(AnalysisHelper.scala:90)
-//   at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)
-//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.$anonfun$resolveOperatorsUp$1(AnalysisHelper.scala:90)
-//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.allowInvokingTransformsInAnalyzer(AnalysisHelper.scala:221)
-//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.resolveOperatorsUp(AnalysisHelper.scala:86)
-//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.resolveOperatorsUp$(AnalysisHelper.scala:84)
-//   at org.apache.spark.sql.catalyst.plans.logical.LogicalPlan.resolveOperatorsUp(LogicalPlan.scala:29)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$.apply(Analyzer.scala:2503)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$.apply(Analyzer.scala:2447)
-//   at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$2(RuleExecutor.scala:216)
-//   at scala.collection.LinearSeqOptimized.foldLeft(LinearSeqOptimized.scala:126)
-//   at scala.collection.LinearSeqOptimized.foldLeft$(LinearSeqOptimized.scala:122)
-//   at scala.collection.immutable.List.foldLeft(List.scala:91)
-//   at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$1(RuleExecutor.scala:213)
-//   at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$1$adapted(RuleExecutor.scala:205)
-//   at scala.collection.immutable.List.foreach(List.scala:431)
-//   at org.apache.spark.sql.catalyst.rules.RuleExecutor.execute(RuleExecutor.scala:205)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer.org$apache$spark$sql$catalyst$analysis$Analyzer$$executeSameContext(Analyzer.scala:195)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer.execute(Analyzer.scala:189)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer.execute(Analyzer.scala:154)
-//   at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$executeAndTrack$1(RuleExecutor.scala:183)
-//   at org.apache.spark.sql.catalyst.QueryPlanningTracker$.withTracker(QueryPlanningTracker.scala:88)
-//   at org.apache.spark.sql.catalyst.rules.RuleExecutor.executeAndTrack(RuleExecutor.scala:183)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:173)
-//   at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)
-//   at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)
-//   at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)
-//   at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)
-//   at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)
-//   at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)
-//   at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)
-//   at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)
-//   at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)
-//   at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)
-//   at org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:90)
-//   at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)
-//   at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:88)
-//   at org.apache.spark.sql.Dataset.withPlan(Dataset.scala:3715)
-//   at org.apache.spark.sql.Dataset.select(Dataset.scala:1462)
-//   ... 42 elided
-
                  -

                  Collecting data to the driver

                  -

                  In Frameless all Spark actions (such as collect()) are safe.

                  -

                  Take the first element from a dataset (if the dataset is empty return None).

                  -
                  cityBeds.headOption.run()
-// res30: Option[CityBeds] = Some(CityBeds(Paris,2))
-
                  -

                  Take the first n elements.

                  -
                  cityBeds.take(2).run()
-// res31: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3))
-
                  -
                  cityBeds.head(3).run()
-// res32: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1))
-
                  -
                  cityBeds.limit(4).collect().run()
-// res33: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1), CityBeds(Lyon,2))
-
                  -

                  Sorting columns

                  -

                  Only column types that can be sorted are allowed to be selected for sorting.

                  -
                  aptTypedDs.orderBy(aptTypedDs('city).asc).show(2).run()
-// +----+-------+--------+--------+
-// |city|surface|   price|bedrooms|
-// +----+-------+--------+--------+
-// |Lyon|     45|133000.0|       1|
-// |Lyon|     83|200000.0|       2|
-// +----+-------+--------+--------+
-// only showing top 2 rows
-//
-
                  -

                  The ordering can be changed by selecting .acs or .desc.

                  -
                  aptTypedDs.orderBy(
-   aptTypedDs('city).asc, 
-   aptTypedDs('price).desc
-).show(2).run()
-// +----+-------+--------+--------+
-// |city|surface|   price|bedrooms|
-// +----+-------+--------+--------+
-// |Lyon|     83|200000.0|       2|
-// |Lyon|     45|133000.0|       1|
-// +----+-------+--------+--------+
-// only showing top 2 rows
-//
-
                  -

                  User Defined Functions

                  -

                  Frameless supports lifting any Scala function (up to five arguments) to the -context of a particular TypedDataset:

                  -
                  // The function we want to use as UDF
-val priceModifier =
-    (name: String, price:Double) => if(name == "Paris") price * 2.0 else price
-// priceModifier: (String, Double) => Double = <function2>
-
-val udf = aptTypedDs.makeUDF(priceModifier)
-// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = frameless.functions.Udf$$Lambda$12549/0x0000000803898840@61521397
-
-val aptds = aptTypedDs // For shorter expressions
-// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
-
-val adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))
-// adjustedPrice: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]
-
-adjustedPrice.show().run()
-// +-----+--------+
-// |   _1|      _2|
-// +-----+--------+
-// |Paris|600000.0|
-// |Paris|900000.0|
-// |Paris|500000.0|
-// | Lyon|200000.0|
-// | Lyon|133000.0|
-// | Nice|325000.0|
-// +-----+--------+
-//
-
                  -

                  GroupBy and Aggregations

                  -

                  Let's suppose we wanted to retrieve the average apartment price in each city

                  -
                  val priceByCity = aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('price)))
-// priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]
-
-priceByCity.collect().run()
-// res38: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))
-
                  -

                  Again if we try to aggregate a column that can't be aggregated, we get a compilation error

                  -
                  aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))
-// <console>:35: error: Cannot compute average of type String.
-//        aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))
-//                                                     ^
-
                  -

                  Next, we combine select and groupBy to calculate the average price/surface ratio per city:

                  -
                  val aptds = aptTypedDs // For shorter expressions
-// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]
-
-val cityPriceRatio =  aptds.select(aptds('city), aptds('price) / aptds('surface).cast[Double])
-// cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]
-
-cityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()
-// +-----+------------------+
-// |   _1|                _2|
-// +-----+------------------+
-// | Nice| 4391.891891891892|
-// |Paris| 6833.333333333333|
-// | Lyon|2682.5970548862115|
-// +-----+------------------+
-//
-
                  -

                  We can also use pivot to further group data on a secondary column. -For example, we can compare the average price across cities by number of bedrooms.

                  -
                  case class BedroomStats(
-   city: String,
-   AvgPriceBeds1: Option[Double], // Pivot values may be missing, so we encode them using Options
-   AvgPriceBeds2: Option[Double],
-   AvgPriceBeds3: Option[Double],
-   AvgPriceBeds4: Option[Double])
-// defined class BedroomStats
-
-val bedroomStats = aptds.
-   groupBy(aptds('city)).
-   pivot(aptds('bedrooms)).
-   on(1,2,3,4). // We only care for up to 4 bedrooms
-   agg(avg(aptds('price))).
-   as[BedroomStats]  // Typesafe casting
-// bedroomStats: frameless.TypedDataset[BedroomStats] = [city: string, AvgPriceBeds1: double ... 3 more fields]
-
-bedroomStats.show().run()
-// +-----+-------------+-------------+-------------+-------------+
-// | city|AvgPriceBeds1|AvgPriceBeds2|AvgPriceBeds3|AvgPriceBeds4|
-// +-----+-------------+-------------+-------------+-------------+
-// | Nice|         null|         null|     325000.0|         null|
-// |Paris|     250000.0|     300000.0|     450000.0|         null|
-// | Lyon|     133000.0|     200000.0|         null|         null|
-// +-----+-------------+-------------+-------------+-------------+
-//
-
                  -

                  With pivot, collecting data preserves typesafety by -encoding potentially missing columns with Option.

                  -
                  bedroomStats.collect().run().foreach(println)
-// BedroomStats(Nice,None,None,Some(325000.0),None)
-// BedroomStats(Paris,Some(250000.0),Some(300000.0),Some(450000.0),None)
-// BedroomStats(Lyon,Some(133000.0),Some(200000.0),None,None)
-
                  -

                  Working with Optional fields

                  -

                  Optional fields can be converted to non-optional using getOrElse().

                  -
                  val sampleStats = bedroomStats.select(
-   bedroomStats('AvgPriceBeds2).getOrElse(0.0),
-   bedroomStats('AvgPriceBeds3).getOrElse(0.0))
-// sampleStats: frameless.TypedDataset[(Double, Double)] = [_1: double, _2: double]
-
-sampleStats.show().run()   
-// +--------+--------+
-// |      _1|      _2|
-// +--------+--------+
-// |     0.0|325000.0|
-// |300000.0|450000.0|
-// |200000.0|     0.0|
-// +--------+--------+
-//
-
                  -

                  In addition, optional columns can be flatten using the .flattenOption method on TypedDatset. -The result contains the rows for which the flattened column is not None (or null). The schema -is automatically adapted to reflect this change.

                  -
                  val flattenStats = bedroomStats.flattenOption('AvgPriceBeds2)
-// flattenStats: frameless.TypedDataset[this.Out] = [_1: string, _2: double ... 3 more fields]
-
-// The second Option[Double] is now of type Double, since all 'null' values are removed
-flattenStats: TypedDataset[(String, Option[Double], Double, Option[Double], Option[Double])]
-// res45: frameless.TypedDataset[(String, Option[Double], Double, Option[Double], Option[Double])] = [_1: string, _2: double ... 3 more fields]
-
                  -

                  In a DataFrame, if you just ignore types, this would equivelantly be written as:

                  -
                  bedroomStats.dataset.toDF().filter($"AvgPriceBeds2".isNotNull)
-// res46: org.apache.spark.sql.Dataset[org.apache.spark.sql.Row] = [city: string, AvgPriceBeds1: double ... 3 more fields]
-
                  -

                  Entire TypedDataset Aggregation

                  -

                  We often want to aggregate the entire TypedDataset and skip the groupBy() clause. -In Frameless you can do this using the agg() operator directly on the TypedDataset. -In the following example, we compute the average price, the average surface, -the minimum surface, and the set of cities for the entire dataset.

                  -
                  case class Stats(
-   avgPrice: Double,
-   avgSurface: Double,
-   minSurface: Int,
-   allCities: Vector[String])
-// defined class Stats
-
-aptds.agg(
-   avg(aptds('price)),
-   avg(aptds('surface)),
-   min(aptds('surface)),
-   collectSet(aptds('city))
-).as[Stats].show().run()
-// +-----------------+------------------+----------+-------------------+
-// |         avgPrice|        avgSurface|minSurface|          allCities|
-// +-----------------+------------------+----------+-------------------+
-// |276333.3333333333|62.833333333333336|        25|[Paris, Nice, Lyon]|
-// +-----------------+------------------+----------+-------------------+
-//
-
                  -

                  You may apply any TypedColumn operation to a TypedAggregate column as well.

                  -
                  import frameless.functions._
-// import frameless.functions._
-
-aptds.agg(
-   avg(aptds('price)) * min(aptds('surface)).cast[Double], 
-   avg(aptds('surface)) * 0.2,
-   litAggr("Hello World")
-).show().run()
-// +-----------------+------------------+-----------+
-// |               _1|                _2|         _3|
-// +-----------------+------------------+-----------+
-// |6908333.333333333|12.566666666666668|Hello World|
-// +-----------------+------------------+-----------+
-//
-
                  -

                  Joins

                  -
                  case class CityPopulationInfo(name: String, population: Int)
-
-val cityInfo = Seq(
-  CityPopulationInfo("Paris", 2229621),
-  CityPopulationInfo("Lyon", 500715),
-  CityPopulationInfo("Nice", 343629)
-)
-
-val citiInfoTypedDS = TypedDataset.create(cityInfo)
-
                  -

                  Here is how to join the population information to the apartment's dataset:

                  -
                  val withCityInfo = aptTypedDs.joinInner(citiInfoTypedDS) { aptTypedDs('city) === citiInfoTypedDS('name) }
-// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct<city: string, surface: int ... 2 more fields>, _2: struct<name: string, population: int>]
-
-withCityInfo.show().run()
-// +--------------------+----------------+
-// |                  _1|              _2|
-// +--------------------+----------------+
-// |{Paris, 50, 30000...|{Paris, 2229621}|
-// |{Paris, 100, 4500...|{Paris, 2229621}|
-// |{Paris, 25, 25000...|{Paris, 2229621}|
-// |{Lyon, 83, 200000...|  {Lyon, 500715}|
-// |{Lyon, 45, 133000...|  {Lyon, 500715}|
-// |{Nice, 74, 325000...|  {Nice, 343629}|
-// +--------------------+----------------+
-//
-
                  -

                  The joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].

                  -

                  We can then select which information we want to continue to work with:

                  -
                  case class AptPriceCity(city: String, aptPrice: Double, cityPopulation: Int)
-// defined class AptPriceCity
-
-withCityInfo.select(
-   withCityInfo.colMany('_2, 'name), withCityInfo.colMany('_1, 'price), withCityInfo.colMany('_2, 'population)
-).as[AptPriceCity].show().run
-// +-----+--------+--------------+
-// | city|aptPrice|cityPopulation|
-// +-----+--------+--------------+
-// |Paris|300000.0|       2229621|
-// |Paris|450000.0|       2229621|
-// |Paris|250000.0|       2229621|
-// | Lyon|200000.0|        500715|
-// | Lyon|133000.0|        500715|
-// | Nice|325000.0|        343629|
-// +-----+--------+--------------+
-//
-
                  - - -
                  - -
                  -
                  -
                  - -

                  results matching ""

                  -
                    - -
                    -
                    - -

                    No results matching ""

                    - -
                    -
                    -
                    - -
                    -
                    - -
                    - - - - - - - - - - - - - +

                    Typesafe column referencing

                    +

                    This is how we select a particular column from a TypedDataset:

                    + 
                    val cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))
+// cities: TypedDataset[String] = [value: string]
                    +

                    This is completely type-safe, for instance suppose we misspell city as citi:

                    + 
                    aptTypedDs.select(aptTypedDs('citi))
+// error: No column Symbol with shapeless.tag.Tagged[String("citi")] of type A in repl.MdocSession.App0.Apartment
+// aptTypedDs.select(aptTypedDs('citi))
+//                             ^
                    +

                    This gets raised at compile time, whereas with the standard Dataset API the error appears at runtime (enjoy the stack trace):

                    + 
                    aptDs.select('citi)
+// org.apache.spark.sql.AnalysisException: cannot resolve 'citi' given input columns: [bedrooms, city, price, surface];
+// 'Project ['citi]
+// +- LocalRelation [city#64, surface#65, price#66, bedrooms#67]
+// 
+// 	at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:54)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:179)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:175)
+// 	at org.apache.spark.sql.catalyst.trees.TreeNode.$anonfun$transformUpWithPruning$2(TreeNode.scala:535)
+// 	at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:82)
+// 	at org.apache.spark.sql.catalyst.trees.TreeNode.transformUpWithPruning(TreeNode.scala:535)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$transformExpressionsUpWithPruning$1(QueryPlan.scala:181)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$1(QueryPlan.scala:193)
+// 	at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:82)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:193)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:204)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$3(QueryPlan.scala:209)
+// 	at scala.collection.TraversableLike.$anonfun$map$1(TraversableLike.scala:286)
+// 	at scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)
+// 	at scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)
+// 	at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)
+// 	at scala.collection.TraversableLike.map(TraversableLike.scala:286)
+// 	at scala.collection.TraversableLike.map$(TraversableLike.scala:279)
+// 	at scala.collection.AbstractTraversable.map(Traversable.scala:108)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:209)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$4(QueryPlan.scala:214)
+// 	at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:323)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:214)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUpWithPruning(QueryPlan.scala:181)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:161)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1(CheckAnalysis.scala:175)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1$adapted(CheckAnalysis.scala:94)
+// 	at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:263)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:94)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:91)
+// 	at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:172)
+// 	at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:195)
+// 	at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:330)
+// 	at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:192)
+// 	at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:88)
+// 	at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)
+// 	at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:196)
+// 	at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:775)
+// 	at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:196)
+// 	at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:88)
+// 	at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:86)
+// 	at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:78)
+// 	at org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:90)
+// 	at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:775)
+// 	at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:88)
+// 	at org.apache.spark.sql.Dataset.withPlan(Dataset.scala:3734)
+// 	at org.apache.spark.sql.Dataset.select(Dataset.scala:1454)
+// 	at repl.MdocSession$App0$$anonfun$25.apply(FeatureOverview.md:95)
+// 	at repl.MdocSession$App0$$anonfun$25.apply(FeatureOverview.md:95)
                    +

                    select() supports arbitrary column operations:

                    + 
                    aptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()
+// +----+---+
+// |  _1| _2|
+// +----+---+
+// | 500| 52|
+// |1000|102|
+// | 250| 27|
+// | 830| 85|
+// | 450| 47|
+// | 740| 76|
+// +----+---+
+//
                    +

                    Note that unlike the standard Spark API, where some operations are lazy and some are not, all TypedDatasets operations are lazy. + In the above example, show() is lazy. It requires to apply run() for the show job to materialize. + A more detailed explanation of Job is given here.

                    +

                    Next we compute the price by surface unit:

                    + 
                    val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))
+// error: overloaded method value / with alternatives:
+//   (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[repl.MdocSession.App0.Apartment,Double] <and>
+//   [Out, TT, W](other: frameless.TypedColumn[TT,Double])(implicit n: frameless.CatalystDivisible[Double,Out], implicit e: frameless.TypedEncoder[Out], implicit w: frameless.With[repl.MdocSession.App0.Apartment,TT]{type Out = W})frameless.TypedColumn[W,Out]
+//  cannot be applied to (frameless.TypedColumn[repl.MdocSession.App0.Apartment,Int])
+// val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])
+//                                            ^^^^^^^^^^^^^^^^^^^^
                    +

                    As the error suggests, we can't divide a TypedColumn of Double by Int. + For safety, in Frameless only math operations between same types is allowed:

                    + 
                    val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])
+// priceBySurfaceUnit: TypedDataset[Double] = [value: double]
+priceBySurfaceUnit.collect().run()
+// res5: Seq[Double] = WrappedArray(
+//   6000.0,
+//   4500.0,
+//   10000.0,
+//   2409.6385542168673,
+//   2955.5555555555557,
+//   4391.891891891892
+// )
                    +

                    Looks like it worked, but that cast seems unsafe right? Actually it is safe. + Let's try to cast a TypedColumn of String to Double:

                    + 
                    aptTypedDs('city).cast[Double]
+// error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]
+// val updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]
+//               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                    +

                    The compile-time error tells us that to perform the cast, an evidence + (in the form of CatalystCast[String, Double]) must be available. + Since casting from String to Double is not allowed, this results + in a compilation error.

                    +

                    Check here + for the set of available CatalystCast.

                    -
                    - - - - +

                    Working with Optional columns

                    +

                    When working with real data we have to deal with imperfections, such as missing fields. Columns that may have + missing data should be represented using Options. For this example, let's assume that the Apartments dataset + may have missing values.

                    + 
                    case class ApartmentOpt(city: Option[String], surface: Option[Int], price: Option[Double], bedrooms: Option[Int])
                    + 
                    val apartmentsOpt = Seq(
+  ApartmentOpt(Some("Paris"), Some(50),  Some(300000.0), None),
+  ApartmentOpt(None, None, Some(450000.0), Some(3))
+)
                    + 
                    val aptTypedDsOpt = TypedDataset.create(apartmentsOpt)
+// aptTypedDsOpt: TypedDataset[ApartmentOpt] = [city: string, surface: int ... 2 more fields]
+aptTypedDsOpt.show().run()
+// +-----+-------+--------+--------+
+// | city|surface|   price|bedrooms|
+// +-----+-------+--------+--------+
+// |Paris|     50|300000.0|    null|
+// | null|   null|450000.0|       3|
+// +-----+-------+--------+--------+
+//
                    +

                    Unfortunately the syntax used above with select() will not work here:

                    + 
                    aptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()
+// error: overloaded method value * with alternatives:
+//   (u: Option[Int])(implicit n: frameless.CatalystNumeric[Option[Int]])frameless.TypedColumn[ApartmentOpt,Option[Int]] <and>
+//   [TT, W](other: frameless.TypedColumn[TT,Option[Int]])(implicit n: frameless.CatalystNumeric[Option[Int]], implicit w: frameless.With[ApartmentOpt,TT]{type Out = W}, implicit t: scala.reflect.ClassTag[Option[Int]])frameless.TypedColumn[W,Option[Int]]
+//  cannot be applied to (Int)
+// aptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()
+//                      ^^^^^^^^^^^^^^^^^^^^^^^^^
+// error: overloaded method value + with alternatives:
+//   (u: Option[Int])(implicit n: frameless.CatalystNumeric[Option[Int]])frameless.TypedColumn[ApartmentOpt,Option[Int]] <and>
+//   [TT, W](other: frameless.TypedColumn[TT,Option[Int]])(implicit n: frameless.CatalystNumeric[Option[Int]], implicit w: frameless.With[ApartmentOpt,TT]{type Out = W})frameless.TypedColumn[W,Option[Int]]
+//  cannot be applied to (Int)
+// aptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()
+//                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^
                    +

                    This is because we cannot multiple an Option with an Int. In Scala, Option has a map() method to help address + exactly this (e.g., Some(10).map(c => c * 2)). Frameless follows a similar convention. By applying the opt method on + any Option[X] column you can then use map() to provide a function that works with the unwrapped type X. + This is best shown in the example bellow:

                    + 
                    aptTypedDsOpt.select(aptTypedDsOpt('surface).opt.map(c => c * 10), aptTypedDsOpt('surface).opt.map(_ + 2)).show().run()
                    +

                    Known issue: map() will throw a runtime exception when the applied function includes a udf(). If you want to + apply a udf() to an optional column, we recommend changing your udf to work directly with Optional fields.

                    - - - +

                    Casting and projections

                    +

                    In the general case, select() returns a TypedDataset of type TypedDataset[TupleN[...]] (with N in [1...10]). + For example, if we select three columns with types String, Int, and Boolean the result will have type + TypedDataset[(String, Int, Boolean)].

                    +

                    We often want to give more expressive types to the result of our computations. + as[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long + as the types in U and T align.

                    +

                    When the cast is valid the expression compiles:

                    + 
                    case class UpdatedSurface(city: String, surface: Int)
+val updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]
+// updated: TypedDataset[UpdatedSurface] = [city: string, surface: int]
+updated.show(2).run()
+// +-----+-------+
+// | city|surface|
+// +-----+-------+
+// |Paris|     52|
+// |Paris|    102|
+// +-----+-------+
+// only showing top 2 rows
+//
                    +

                    Next we try to cast a (String, String) to an UpdatedSurface (which has types String, Int). + The cast is not valid and the expression does not compile:

                    + 
                    aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]
+// error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]
+// aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                    - +

                    Advanced topics with select()

                    +

                    When you select() a single column that has type A, the resulting type is TypedDataset[A] and + not TypedDataset[Tuple1[A]]. This behavior makes working with nested schema easier (i.e., in the case + where A is a complex data type) and simplifies type-checking column operations (e.g., verify that two + columns can be added, divided, etc.). However, when A is scalar, say a Long, it makes it harder to select + and work with the resulting TypedDataset[Long]. For instance, it's harder to reference this single scalar + column using select(). If this becomes an issue, you can bypass this behavior by using the + selectMany() method instead of select(). In the previous example, selectMany() will return + TypedDataset[Tuple1[Long]] and you can reference its single column using the name _1. + selectMany() should also be used when you need to select more than 10 columns. + select() has better IDE support and compiles faster than the macro based selectMany(), + so prefer select() for the most common use cases.

                    +

                    When you are handed a single scalar column TypedDataset (e.g., TypedDataset[Double]) + the best way to reference its single column is using the asCol (short for "as a column") method. + This is best shown in the example below. We will see more usages of asCol later in this tutorial.

                    + 
                    val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])
+// priceBySurfaceUnit: TypedDataset[Double] = [value: double]
+priceBySurfaceUnit.select(priceBySurfaceUnit.asCol * 2).show(2).run()
+// +-------+
+// |  value|
+// +-------+
+// |12000.0|
+// | 9000.0|
+// +-------+
+// only showing top 2 rows
+//
                    - +

                    Projections

                    +

                    We often want to work with a subset of the fields in a dataset. + Projections allow us to easily select our fields of interest + while preserving their initial names and types for extra safety.

                    +

                    Here is an example using the TypedDataset[Apartment] with an additional column:

                    + 
                    val aptds = aptTypedDs // For shorter expressions
+// aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions
+
+case class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)
+val aptWithRatio =
+  aptds.select(
+    aptds('city),
+    aptds('price),
+    aptds('surface),
+    aptds('price) / aptds('surface).cast[Double]
+  ).as[ApartmentDetails]
+// aptWithRatio: TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]
                    +

                    Suppose we only want to work with city and ratio:

                    + 
                    case class CityInfo(city: String, ratio: Double)
+
+val cityRatio = aptWithRatio.project[CityInfo]
+// cityRatio: TypedDataset[CityInfo] = [city: string, ratio: double]
+
+cityRatio.show(2).run()
+// +-----+------+
+// | city| ratio|
+// +-----+------+
+// |Paris|6000.0|
+// |Paris|4500.0|
+// +-----+------+
+// only showing top 2 rows
+//
                    +

                    Suppose we only want to work with price and ratio:

                    + 
                    case class PriceInfo(ratio: Double, price: Double)
+
+val priceInfo = aptWithRatio.project[PriceInfo]
+// priceInfo: TypedDataset[PriceInfo] = [ratio: double, price: double]
+
+priceInfo.show(2).run()
+// +------+--------+
+// | ratio|   price|
+// +------+--------+
+// |6000.0|300000.0|
+// |4500.0|450000.0|
+// +------+--------+
+// only showing top 2 rows
+//
                    +

                    We see that the order of the fields does not matter as long as the + names and the corresponding types agree. However, if we make a mistake in + any of the names and/or their types, then we get a compilation error.

                    +

                    Say we make a typo in a field name:

                    + 
                    case class PriceInfo2(ratio: Double, pricEE: Double)
                    + 
                    aptWithRatio.project[PriceInfo2]
+// error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?
+// aptWithRatio.project[PriceInfo2]
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                    +

                    Say we make a mistake in the corresponding type:

                    + 
                    case class PriceInfo3(ratio: Int, price: Double) // ratio should be Double
                    + 
                    aptWithRatio.project[PriceInfo3]
+// error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?
+// aptWithRatio.project[PriceInfo3]
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                    - +

                    Union of TypedDatasets

                    +

                    Lets create a projection of our original dataset with a subset of the fields.

                    + 
                    case class ApartmentShortInfo(city: String, price: Double, bedrooms: Int)
+
+val aptTypedDs2: TypedDataset[ApartmentShortInfo] = aptTypedDs.project[ApartmentShortInfo]
                    +

                    The union of aptTypedDs2 with aptTypedDs uses all the fields of the caller (aptTypedDs2) + and expects the other dataset (aptTypedDs) to include all those fields. + If field names/types do not match you get a compilation error.

                    + 
                    aptTypedDs2.union(aptTypedDs).show().run
+// +-----+--------+--------+
+// | city|   price|bedrooms|
+// +-----+--------+--------+
+// |Paris|300000.0|       2|
+// |Paris|450000.0|       3|
+// |Paris|250000.0|       1|
+// | Lyon|200000.0|       2|
+// | Lyon|133000.0|       1|
+// | Nice|325000.0|       3|
+// |Paris|300000.0|       2|
+// |Paris|450000.0|       3|
+// |Paris|250000.0|       1|
+// | Lyon|200000.0|       2|
+// | Lyon|133000.0|       1|
+// | Nice|325000.0|       3|
+// +-----+--------+--------+
+//
                    +

                    The other way around will not compile, since aptTypedDs2 has only a subset of the fields.

                    + 
                    aptTypedDs.union(aptTypedDs2).show().run
+// error: Cannot prove that ApartmentShortInfo can be projected to repl.MdocSession.App0.Apartment. Perhaps not all member names and types of repl.MdocSession.App0.Apartment are the same in ApartmentShortInfo?
+// Error occurred in an application involving default arguments.
+// aptTypedDs.union(aptTypedDs2).show().run
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                    +

                    Finally, as with project, union will align fields that have same names/types, + so fields do not have to be in the same order.

                    - +

                    TypedDataset functions and transformations

                    +

                    Frameless supports many of Spark's functions and transformations. + However, whenever a Spark function does not exist in Frameless, + calling .dataset will expose the underlying + Dataset (from org.apache.spark.sql, the original Spark APIs), + where you can use anything that would be missing from the Frameless' API.

                    +

                    These are the main imports for Frameless' aggregate and non-aggregate functions.

                    + 
                    import frameless.functions._                // For literals
+import frameless.functions.nonAggregate._   // e.g., concat, abs
+import frameless.functions.aggregate._      // e.g., count, sum, avg
                    - +

                    Drop/Replace/Add fields

                    +

                    dropTupled() drops a single column and results in a tuple-based schema.

                    + 
                    aptTypedDs2.dropTupled('price): TypedDataset[(String,Int)]
+// res18: TypedDataset[(String, Int)] = [_1: string, _2: int]
                    +

                    To drop a column and specify a new schema use drop().

                    + 
                    case class CityBeds(city: String, bedrooms: Int)
+val cityBeds: TypedDataset[CityBeds] = aptTypedDs2.drop[CityBeds] 
+// cityBeds: TypedDataset[CityBeds] = [city: string, bedrooms: int]
                    +

                    Often, you want to replace an existing column with a new value.

                    + 
                    val inflation = aptTypedDs2.withColumnReplaced('price, aptTypedDs2('price) * 2)
+// inflation: TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]
+ 
+inflation.show(2).run()
+// +-----+--------+--------+
+// | city|   price|bedrooms|
+// +-----+--------+--------+
+// |Paris|600000.0|       2|
+// |Paris|900000.0|       3|
+// +-----+--------+--------+
+// only showing top 2 rows
+//
                    +

                    Or use a literal instead.

                    + 
                    import frameless.functions.lit
+aptTypedDs2.withColumnReplaced('price, lit(0.001)) 
+// res20: TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]
                    +

                    Adding a column using withColumnTupled() results in a tupled-based schema.

                    + 
                    aptTypedDs2.withColumnTupled(lit(Array("a","b","c"))).show(2).run()
+// +-----+--------+---+---------+
+// |   _1|      _2| _3|       _4|
+// +-----+--------+---+---------+
+// |Paris|300000.0|  2|[a, b, c]|
+// |Paris|450000.0|  3|[a, b, c]|
+// +-----+--------+---+---------+
+// only showing top 2 rows
+//
                    +

                    Similarly, withColumn() adds a column and explicitly expects a schema for the result.

                    + 
                    case class CityBedsOther(city: String, bedrooms: Int, other: List[String])
+
+cityBeds.
+   withColumn[CityBedsOther](lit(List("a","b","c"))).
+   show(1).run()
+// +-----+--------+---------+
+// | city|bedrooms|    other|
+// +-----+--------+---------+
+// |Paris|       2|[a, b, c]|
+// +-----+--------+---------+
+// only showing top 1 row
+//
                    +

                    To conditionally change a column use the when/otherwise operation.

                    + 
                    import frameless.functions.nonAggregate.when
+aptTypedDs2.withColumnTupled(
+   when(aptTypedDs2('city) === "Paris", aptTypedDs2('price)).
+   when(aptTypedDs2('city) === "Lyon", lit(1.1)).
+   otherwise(lit(0.0))).show(8).run()
+// +-----+--------+---+--------+
+// |   _1|      _2| _3|      _4|
+// +-----+--------+---+--------+
+// |Paris|300000.0|  2|300000.0|
+// |Paris|450000.0|  3|450000.0|
+// |Paris|250000.0|  1|250000.0|
+// | Lyon|200000.0|  2|     1.1|
+// | Lyon|133000.0|  1|     1.1|
+// | Nice|325000.0|  3|     0.0|
+// +-----+--------+---+--------+
+//
                    +

                    A simple way to add a column without losing important schema information is + to project the entire source schema into a single column using the asCol() method.

                    + 
                    val c = cityBeds.select(cityBeds.asCol, lit(List("a","b","c")))
+// c: TypedDataset[(CityBeds, List[String])] = [_1: struct<city: string, bedrooms: int>, _2: array<string>]
+c.show(1).run()
+// +----------+---------+
+// |        _1|       _2|
+// +----------+---------+
+// |{Paris, 2}|[a, b, c]|
+// +----------+---------+
+// only showing top 1 row
+//
                    +

                    When working with Spark's DataFrames, you often select all columns using .select($"*", ...). + In a way, asCol() is a typed equivalent of $"*".

                    +

                    To access nested columns, use the colMany() method.

                    + 
                    c.select(c.colMany('_1, 'city), c('_2)).show(2).run()
+// +-----+---------+
+// |   _1|       _2|
+// +-----+---------+
+// |Paris|[a, b, c]|
+// |Paris|[a, b, c]|
+// +-----+---------+
+// only showing top 2 rows
+//
                    - +

                    Working with collections

                    + 
                    import frameless.functions._
+import frameless.functions.nonAggregate._
                    + 
                    val t = cityRatio.select(cityRatio('city), lit(List("abc","c","d")))
+// t: TypedDataset[(String, List[String])] = [_1: string, _2: array<string>]
+t.withColumnTupled(
+   arrayContains(t('_2), "abc")
+).show(1).run()
+// +-----+-----------+----+
+// |   _1|         _2|  _3|
+// +-----+-----------+----+
+// |Paris|[abc, c, d]|true|
+// +-----+-----------+----+
+// only showing top 1 row
+//
                    +

                    If accidentally you apply a collection function on a column that is not a collection, + you get a compilation error.

                    + 
                    t.withColumnTupled(
+   arrayContains(t('_1), "abc")
+)
+// error: no type parameters for method arrayContains: (column: frameless.AbstractTypedColumn[T,C[A]], value: A)(implicit evidence$1: frameless.CatalystCollection[C])column.ThisType[T,Boolean] exist so that it can be applied to arguments (frameless.TypedColumn[(String, List[String]),String], String)
+//  --- because ---
+// argument expression's type is not compatible with formal parameter type;
+//  found   : frameless.TypedColumn[(String, List[String]),String]
+//  required: frameless.AbstractTypedColumn[?T,?C[?A]]
+// 
+// Error occurred in an application involving default arguments.
+//    arrayContains(t('_1), "abc")
+//    ^^^^^^^^^^^^^
+// error: type mismatch;
+//  found   : frameless.TypedColumn[(String, List[String]),String]
+//  required: frameless.AbstractTypedColumn[T,C[A]]
+// Error occurred in an application involving default arguments.
+//    arrayContains(t('_1), "abc")
+//                  ^^^^^^
+// error: type mismatch;
+//  found   : String("abc")
+//  required: A
+// Error occurred in an application involving default arguments.
+//    arrayContains(t('_1), "abc")
+//                          ^^^^^
+// error: Cannot do collection operations on columns of type C.
+// Error occurred in an application involving default arguments.
+//    arrayContains(t('_1), "abc")
+//                 ^
                    +

                    Flattening columns in Spark is done with the explode() method. Unlike vanilla Spark, + in Frameless explode() is part of TypedDataset and not a function of a column. + This provides additional safety since more than one explode() applied in a single + statement results in runtime error in vanilla Spark.

                    + 
                    val t2 = cityRatio.select(cityRatio('city), lit(List(1,2,3,4)))
+// t2: TypedDataset[(String, List[Int])] = [_1: string, _2: array<int>]
+val flattened = t2.explode('_2): TypedDataset[(String, Int)]
+// flattened: TypedDataset[(String, Int)] = [_1: string, _2: int]
+flattened.show(4).run()
+// +-----+---+
+// |   _1| _2|
+// +-----+---+
+// |Paris|  1|
+// |Paris|  2|
+// |Paris|  3|
+// |Paris|  4|
+// +-----+---+
+// only showing top 4 rows
+//
                    +

                    Here is an example of how explode() may fail in vanilla Spark. The Frameless + implementation does not suffer from this problem since, by design, it can only be applied + to a single column at a time.

                    + 
                    {
+  import org.apache.spark.sql.functions.{explode => sparkExplode}
+  t2.dataset.toDF().select(sparkExplode($"_2"), sparkExplode($"_2"))
+}
+// error: Unit does not take parameters
+// Error occurred in an application involving default arguments.
+// flattened.show(4).run()
+// ^^^^^^^^^^^^^
                    - +

                    Collecting data to the driver

                    +

                    In Frameless all Spark actions (such as collect()) are safe.

                    +

                    Take the first element from a dataset (if the dataset is empty return None).

                    + 
                    cityBeds.headOption.run()
+// res30: Option[CityBeds] = Some(CityBeds("Paris", 2))
                    +

                    Take the first n elements.

                    + 
                    cityBeds.take(2).run()
+// res31: Seq[CityBeds] = WrappedArray(
+//   CityBeds("Paris", 2),
+//   CityBeds("Paris", 3)
+// )
                    + 
                    cityBeds.head(3).run()
+// res32: Seq[CityBeds] = WrappedArray(
+//   CityBeds("Paris", 2),
+//   CityBeds("Paris", 3),
+//   CityBeds("Paris", 1)
+// )
                    + 
                    cityBeds.limit(4).collect().run()
+// res33: Seq[CityBeds] = WrappedArray(
+//   CityBeds("Paris", 2),
+//   CityBeds("Paris", 3),
+//   CityBeds("Paris", 1),
+//   CityBeds("Lyon", 2)
+// )
                    - +

                    Sorting columns

                    +

                    Only column types that can be sorted are allowed to be selected for sorting.

                    + 
                    aptTypedDs.orderBy(aptTypedDs('city).asc).show(2).run()
+// +----+-------+--------+--------+
+// |city|surface|   price|bedrooms|
+// +----+-------+--------+--------+
+// |Lyon|     45|133000.0|       1|
+// |Lyon|     83|200000.0|       2|
+// +----+-------+--------+--------+
+// only showing top 2 rows
+//
                    +

                    The ordering can be changed by selecting .acs or .desc.

                    + 
                    aptTypedDs.orderBy(
+   aptTypedDs('city).asc, 
+   aptTypedDs('price).desc
+).show(2).run()
+// +----+-------+--------+--------+
+// |city|surface|   price|bedrooms|
+// +----+-------+--------+--------+
+// |Lyon|     83|200000.0|       2|
+// |Lyon|     45|133000.0|       1|
+// +----+-------+--------+--------+
+// only showing top 2 rows
+//
                    - +

                    User Defined Functions

                    +

                    Frameless supports lifting any Scala function (up to five arguments) to the + context of a particular TypedDataset:

                    + 
                    // The function we want to use as UDF
+val priceModifier =
+    (name: String, price:Double) => if(name == "Paris") price * 2.0 else price
+// priceModifier: (String, Double) => Double = <function2>
+
+val udf = aptTypedDs.makeUDF(priceModifier)
+// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15393/1583643801@75d108db
+
+val aptds = aptTypedDs // For shorter expressions
+// aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions
+
+val adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))
+// adjustedPrice: TypedDataset[(String, Double)] = [_1: string, _2: double]
+
+adjustedPrice.show().run()
+// +-----+--------+
+// |   _1|      _2|
+// +-----+--------+
+// |Paris|600000.0|
+// |Paris|900000.0|
+// |Paris|500000.0|
+// | Lyon|200000.0|
+// | Lyon|133000.0|
+// | Nice|325000.0|
+// +-----+--------+
+//
                    - +

                    GroupBy and Aggregations

                    +

                    Let's suppose we wanted to retrieve the average apartment price in each city

                    + 
                    val priceByCity = aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('price)))
+// priceByCity: TypedDataset[(String, Double)] = [_1: string, _2: double]
+priceByCity.collect().run()
+// res37: Seq[(String, Double)] = WrappedArray(
+//   ("Paris", 333333.3333333333),
+//   ("Nice", 325000.0),
+//   ("Lyon", 166500.0)
+// )
                    +

                    Again if we try to aggregate a column that can't be aggregated, we get a compilation error

                    + 
                    aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))
+// error: Cannot compute average of type String.
+// Error occurred in an application involving default arguments.
+// aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))
+//                                              ^
                    +

                    Next, we combine select and groupBy to calculate the average price/surface ratio per city:

                    + 
                    val aptds = aptTypedDs // For shorter expressions
+// aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions
+
+val cityPriceRatio =  aptds.select(aptds('city), aptds('price) / aptds('surface).cast[Double])
+// cityPriceRatio: TypedDataset[(String, Double)] = [_1: string, _2: double]
+
+cityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()
+// +-----+------------------+
+// |   _1|                _2|
+// +-----+------------------+
+// |Paris| 6833.333333333333|
+// | Nice| 4391.891891891892|
+// | Lyon|2682.5970548862115|
+// +-----+------------------+
+//
                    +

                    We can also use pivot to further group data on a secondary column. + For example, we can compare the average price across cities by number of bedrooms.

                    + 
                    case class BedroomStats(
+   city: String,
+   AvgPriceBeds1: Option[Double], // Pivot values may be missing, so we encode them using Options
+   AvgPriceBeds2: Option[Double],
+   AvgPriceBeds3: Option[Double],
+   AvgPriceBeds4: Option[Double])
+
+val bedroomStats = aptds.
+   groupBy(aptds('city)).
+   pivot(aptds('bedrooms)).
+   on(1,2,3,4). // We only care for up to 4 bedrooms
+   agg(avg(aptds('price))).
+   as[BedroomStats]  // Typesafe casting
+// bedroomStats: TypedDataset[BedroomStats] = [city: string, AvgPriceBeds1: double ... 3 more fields]  // Typesafe casting
+
+bedroomStats.show().run()
+// +-----+-------------+-------------+-------------+-------------+
+// | city|AvgPriceBeds1|AvgPriceBeds2|AvgPriceBeds3|AvgPriceBeds4|
+// +-----+-------------+-------------+-------------+-------------+
+// | Nice|         null|         null|     325000.0|         null|
+// |Paris|     250000.0|     300000.0|     450000.0|         null|
+// | Lyon|     133000.0|     200000.0|         null|         null|
+// +-----+-------------+-------------+-------------+-------------+
+//
                    +

                    With pivot, collecting data preserves typesafety by + encoding potentially missing columns with Option.

                    + 
                    bedroomStats.collect().run().foreach(println)
+// BedroomStats(Nice,None,None,Some(325000.0),None)
+// BedroomStats(Paris,Some(250000.0),Some(300000.0),Some(450000.0),None)
+// BedroomStats(Lyon,Some(133000.0),Some(200000.0),None,None)
                    - +

                    Working with Optional fields

                    +

                    Optional fields can be converted to non-optional using getOrElse().

                    + 
                    val sampleStats = bedroomStats.select(
+   bedroomStats('AvgPriceBeds2).getOrElse(0.0),
+   bedroomStats('AvgPriceBeds3).getOrElse(0.0))
+// sampleStats: TypedDataset[(Double, Double)] = [_1: double, _2: double]
+
+sampleStats.show().run()   
+// +--------+--------+
+// |      _1|      _2|
+// +--------+--------+
+// |     0.0|325000.0|
+// |300000.0|450000.0|
+// |200000.0|     0.0|
+// +--------+--------+
+//
                    +

                    In addition, optional columns can be flatten using the .flattenOption method on TypedDatset. + The result contains the rows for which the flattened column is not None (or null). The schema + is automatically adapted to reflect this change.

                    + 
                    val flattenStats = bedroomStats.flattenOption('AvgPriceBeds2)
+// flattenStats: TypedDataset[(String, Option[Double], Double, Option[Double], Option[Double])] = [_1: string, _2: double ... 3 more fields]
+
+
+// The second Option[Double] is now of type Double, since all 'null' values are removed
+flattenStats: TypedDataset[(String, Option[Double], Double, Option[Double], Option[Double])]
+// res43: TypedDataset[(String, Option[Double], Double, Option[Double], Option[Double])] = [_1: string, _2: double ... 3 more fields]
                    +

                    In a DataFrame, if you just ignore types, this would equivelantly be written as:

                    + 
                    bedroomStats.dataset.toDF().filter($"AvgPriceBeds2".isNotNull)
+// res44: org.apache.spark.sql.Dataset[org.apache.spark.sql.Row] = [city: string, AvgPriceBeds1: double ... 3 more fields]
                    - +

                    Entire TypedDataset Aggregation

                    +

                    We often want to aggregate the entire TypedDataset and skip the groupBy() clause. + In Frameless you can do this using the agg() operator directly on the TypedDataset. + In the following example, we compute the average price, the average surface, + the minimum surface, and the set of cities for the entire dataset.

                    + 
                    case class Stats(
+   avgPrice: Double,
+   avgSurface: Double,
+   minSurface: Int,
+   allCities: Vector[String])
+
+aptds.agg(
+   avg(aptds('price)),
+   avg(aptds('surface)),
+   min(aptds('surface)),
+   collectSet(aptds('city))
+).as[Stats].show().run()
+// +-----------------+------------------+----------+-------------------+
+// |         avgPrice|        avgSurface|minSurface|          allCities|
+// +-----------------+------------------+----------+-------------------+
+// |276333.3333333333|62.833333333333336|        25|[Paris, Nice, Lyon]|
+// +-----------------+------------------+----------+-------------------+
+//
                    +

                    You may apply any TypedColumn operation to a TypedAggregate column as well.

                    + 
                    import frameless.functions._
+aptds.agg(
+   avg(aptds('price)) * min(aptds('surface)).cast[Double], 
+   avg(aptds('surface)) * 0.2,
+   litAggr("Hello World")
+).show().run()
+// +-----------------+------------------+-----------+
+// |               _1|                _2|         _3|
+// +-----------------+------------------+-----------+
+// |6908333.333333333|12.566666666666668|Hello World|
+// +-----------------+------------------+-----------+
+//
                    + +

                    Joins

                    + 
                    case class CityPopulationInfo(name: String, population: Int)
 
-    
-
+val cityInfo = Seq(
+  CityPopulationInfo("Paris", 2229621),
+  CityPopulationInfo("Lyon", 500715),
+  CityPopulationInfo("Nice", 343629)
+)
+
+val citiInfoTypedDS = TypedDataset.create(cityInfo)
                    +

                    Here is how to join the population information to the apartment's dataset:

                    + 
                    val withCityInfo = aptTypedDs.joinInner(citiInfoTypedDS) { aptTypedDs('city) === citiInfoTypedDS('name) }
+// withCityInfo: TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct<city: string, surface: int ... 2 more fields>, _2: struct<name: string, population: int>]
+
+withCityInfo.show().run()
+// +--------------------+----------------+
+// |                  _1|              _2|
+// +--------------------+----------------+
+// |{Paris, 50, 30000...|{Paris, 2229621}|
+// |{Paris, 100, 4500...|{Paris, 2229621}|
+// |{Paris, 25, 25000...|{Paris, 2229621}|
+// |{Lyon, 83, 200000...|  {Lyon, 500715}|
+// |{Lyon, 45, 133000...|  {Lyon, 500715}|
+// |{Nice, 74, 325000...|  {Nice, 343629}|
+// +--------------------+----------------+
+//
                    +

                    The joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].

                    +

                    We can then select which information we want to continue to work with:

                    + 
                    case class AptPriceCity(city: String, aptPrice: Double, cityPopulation: Int)
+
+withCityInfo.select(
+   withCityInfo.colMany('_2, 'name), withCityInfo.colMany('_1, 'price), withCityInfo.colMany('_2, 'population)
+).as[AptPriceCity].show().run
+// +-----+--------+--------------+
+// | city|aptPrice|cityPopulation|
+// +-----+--------+--------------+
+// |Paris|300000.0|       2229621|
+// |Paris|450000.0|       2229621|
+// |Paris|250000.0|       2229621|
+// | Lyon|200000.0|        500715|
+// | Lyon|133000.0|        500715|
+// | Nice|325000.0|        343629|
+// +-----+--------+--------------+
+//
                    + +
                    + + + + \ No newline at end of file diff --git a/Injection.html b/Injection.html index 60fe243e9..386a4dde5 100644 --- a/Injection.html +++ b/Injection.html @@ -1,426 +1,167 @@ - - - - - - - Injection: Creating Custom Encoders · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + Injection: Creating Custom Encoders - - - - - - - - - + - - - - - -
                    -
                    - - - - - - - - -
                    - -
                    -
                    - - - - - - - - -
                    -
                    - -
                    -
                    - -
                    - -

                    Injection: Creating Custom Encoders

                    -

                    Injection lets us define encoders for types that do not have one by injecting A into an encodable type B. -This is the definition of the injection typeclass:

                    -
                    trait Injection[A, B] extends Serializable {
-  def apply(a: A): B
-  def invert(b: B): A
+
                    + + + + + + + + + + + + + +
                    + + + +
                    + +

                    Injection: Creating Custom Encoders

                    +

                    Injection lets us define encoders for types that do not have one by injecting A into an encodable type B. + This is the definition of the injection typeclass:

                    + 
                    trait Injection[A, B] extends Serializable {
+  def apply(a: A): B
+  def invert(b: B): A
+}
                    + +

                    Example

                    +

                    Let's define a simple case class:

                    + 
                    case class Person(age: Int, birthday: java.util.Date)
+val people = Seq(Person(42, new java.util.Date))
+// people: Seq[Person] = List(Person(42, Wed Jan 26 01:09:01 UTC 2022))
                    +

                    And an instance of a TypedDataset:

                    + 
                    val personDS = TypedDataset.create(people)
+// error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
+// val personDS = TypedDataset.create(people)
+//                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
                    +

                    Looks like we can't, a TypedEncoder instance of Person is not available, or more precisely for java.util.Date. + But we can define a injection from java.util.Date to an encodable type, like Long:

                    + 
                    import frameless._
+implicit val dateToLongInjection = new Injection[java.util.Date, Long] {
+  def apply(d: java.util.Date): Long = d.getTime()
+  def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-
                    -

                    Example

                    -

                    Let's define a simple case class:

                    -
                    case class Person(age: Int, birthday: java.util.Date)
-// defined class Person
-
-val people = Seq(Person(42, new java.util.Date))
-// people: Seq[Person] = List(Person(42,Tue Jan 19 20:29:11 PST 2021))
-
                    -

                    And an instance of a TypedDataset:

                    -
                    val personDS = TypedDataset.create(people)
-// <console>:23: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]
-//        val personDS = TypedDataset.create(people)
-//                                          ^
-
                    -

                    Looks like we can't, a TypedEncoder instance of Person is not available, or more precisely for java.util.Date. -But we can define a injection from java.util.Date to an encodable type, like Long:

                    -
                    import frameless._
-// import frameless._
-
-implicit val dateToLongInjection = new Injection[java.util.Date, Long] {
-  def apply(d: java.util.Date): Long = d.getTime()
-  def invert(l: Long): java.util.Date = new java.util.Date(l)
-}
-// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@17559031
-
                    -

                    We can be less verbose using the Injection.apply function:

                    -
                    import frameless._
-// import frameless._
-
-implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@7d716477
-
                    -

                    Now we can create our TypedDataset:

                    -
                    val personDS = TypedDataset.create(people)
-// personDS: frameless.TypedDataset[Person] = [age: int, birthday: bigint]
-
                    -

                    Another example

                    -

                    Let's define a sealed family:

                    -
                    sealed trait Gender
-// defined trait Gender
-
-case object Male extends Gender
-// defined object Male
-
-case object Female extends Gender
-// defined object Female
-
-case object Other extends Gender
-// defined object Other
-
                    -

                    And a simple case class:

                    -
                    case class Person(age: Int, gender: Gender)
-// defined class Person
-
-val people = Seq(Person(42, Male))
-// people: Seq[Person] = List(Person(42,Male))
-
                    -

                    Again if we try to create a TypedDataset, we get a compilation error.

                    -
                    val personDS = TypedDataset.create(people)
-// <console>:31: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]
-//        val personDS = TypedDataset.create(people)
-//                                          ^
-
                    -

                    Let's define an injection instance for Gender:

                    -
                    implicit val genderToInt: Injection[Gender, Int] = Injection(
+// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@4500fae4
                    +

                    We can be less verbose using the Injection.apply function:

                    + 
                    import frameless._
+implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
+// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@6cef1fa2
                    +

                    Now we can create our TypedDataset:

                    + 
                    val personDS = TypedDataset.create(people)
+// personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                    + +

                    Another example

                    +

                    Let's define a sealed family:

                    + 
                    sealed trait Gender
+case object Male extends Gender
+case object Female extends Gender
+case object Other extends Gender
                    +

                    And a simple case class:

                    + 
                    case class Person(age: Int, gender: Gender)
+val people = Seq(Person(42, Male))
+// people: Seq[Person] = List(Person(42, Male))
                    +

                    Again if we try to create a TypedDataset, we get a compilation error.

                    + 
                    val personDS = TypedDataset.create(people)
+// error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App1.Person]
+// val personDS = TypedDataset.create(people)
+//                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
                    +

                    Let's define an injection instance for Gender:

                    + 
                    import frameless._
+implicit val genderToInt: Injection[Gender, Int] = Injection(
   {
-    case Male   => 1
-    case Female => 2
-    case Other  => 3
+    case Male   => 1
+    case Female => 2
+    case Other  => 3
   },
   {
-    case 1 => Male
-    case 2 => Female
-    case 3 => Other
+    case 1 => Male
+    case 2 => Female
+    case 3 => Other
   })
-// <console>:35: warning: match may not be exhaustive.
-// It would fail on the following inputs: Female, Male, Other
-//          {
-//          ^
-// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@7c0fbe02
-
                    -

                    And now we can create our TypedDataset:

                    -
                    val personDS = TypedDataset.create(people)
-// personDS: frameless.TypedDataset[Person] = [age: int, gender: int]
-
                    +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@3951bf91                     +

                    And now we can create our TypedDataset:

                    + 
                    val personDS = TypedDataset.create(people)
+// personDS: TypedDataset[Person] = [age: int, gender: int]
                    +

                    Alternatively, an injection instance can be derived for sealed families such as Gender using the following + import, import frameless.TypedEncoder.injections._. This will encode the data constructors as strings.

                    +

                    Known issue: An invalid injection instance will be derived if there are data constructors with the same name. + For example, consider the following sealed family:

                    + 
                    sealed trait Foo
+object A { case object Bar extends Foo }
+object B { case object Bar extends Foo }
                    +

                    A.Bar and B.Bar will both be encoded as "Bar" thereby breaking the law that invert(apply(x)) == x.

                    + +
                    - - - -
                    -
                    -
                    - -

                    results matching ""

                    -
                      - -
                      -
                      - -

                      No results matching ""

                      - -
                      -
                      - -
                      -
                      - -
                      - - - - - - - - - - - - - - -
                      - - -
                      - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + \ No newline at end of file diff --git a/Job.html b/Job.html index 2fd2ed86e..57f0ce2a8 100644 --- a/Job.html +++ b/Job.html @@ -1,396 +1,147 @@ - - - - - - - Job[A] · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + Job[A] - - - - - - - - - - - - - - - - - -
                      -
                      - - - - - - - - -
                      - -
                      -
                      - - - - - - - - -
                      -
                      - -
                      -
                      - -
                      - -

                      Job[A]

                      -

                      All operations on TypedDataset are lazy. An operation either returns a new -transformed TypedDataset or an F[A], where F[_] is a type constructor -with an instance of the SparkDelay typeclass and A is the result of running a -non-lazy computation in Spark.

                      -

                      A default such type constructor called Job is provided by Frameless.

                      -

                      Job serves several functions:

                      -
                        -
                      • Makes all operations on a TypedDataset lazy, which makes them more predictable compared to having -few operations being lazy and other being strict
                        • -
                      • Allows the programmer to make expensive blocking operations explicit
                        • -
                      • Allows for Spark jobs to be lazily sequenced using monadic composition via for-comprehension
                        • -
                      • Provides an obvious place where you can annotate/name your Spark jobs to make it easier -to track different parts of your application in the Spark UI
                        • -
                      -

                      The toy example showcases the use of for-comprehension to explicitly sequences Spark Jobs. -First we calculate the size of the TypedDataset and then we collect to the driver -exactly 20% of its elements:

                      -
                      import frameless.syntax._
-// import frameless.syntax._
-
-val ds = TypedDataset.create(1 to 20)
-// ds: frameless.TypedDataset[Int] = [value: int]
-
-val countAndTakeJob =
-  for {
-    count <- ds.count()
-    sample <- ds.take((count/5).toInt)
-  } yield sample
-// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@49c2901b
-
-countAndTakeJob.run()
-// res1: Seq[Int] = WrappedArray(1, 2, 3, 4)
-
                      -

                      The countAndTakeJob can either be executed using run() (as we show above) or it can -be passed along to other parts of the program to be further composed into more complex sequences -of Spark jobs.

                      -
                      import frameless.Job
-// import frameless.Job
-
-def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min)
-// computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]
-
-val finalJob = computeMinOfSample(countAndTakeJob)
-// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@123416f3
-
                      -

                      Now we can execute this new job by specifying a group-id and a description. -This allows the programmer to see this information on the Spark UI and help track, say, -performance issues.

                      -
                      finalJob.
-  withGroupId("samplingJob").
-  withDescription("Samples 20% of elements and computes the min").
-  run()
-// res2: Int = 1
-
                      -

                      More on SparkDelay

                      -

                      As mentioned above, SparkDelay[F[_]] is a typeclass required for suspending -effects by Spark computations. This typeclass represents the ability to suspend -an => A thunk into an F[A] value, while implicitly capturing a SparkSession.

                      -

                      As it is a typeclass, it is open for implementation by the user in order to use -other data types for suspension of effects. The cats module, for example, uses -this typeclass to support suspending Spark computations in any effect type that -has a cats.effect.Sync instance.

                      - - -
                      - -
                      -
                      -
                      - -

                      results matching ""

                      -
                        - -
                        -
                        - -

                        No results matching ""

                        - -
                        -
                        -
                        - -
                        -
                        - -
                        +
                        + + + + + + + + + + + + + +
                        + + + +
                        + +

                        Job[A]

                        +

                        All operations on TypedDataset are lazy. An operation either returns a new + transformed TypedDataset or an F[A], where F[_] is a type constructor + with an instance of the SparkDelay typeclass and A is the result of running a + non-lazy computation in Spark.

                        +

                        A default such type constructor called Job is provided by Frameless.

                        +

                        Job serves several functions: + - Makes all operations on a TypedDataset lazy, which makes them more predictable compared to having + few operations being lazy and other being strict + - Allows the programmer to make expensive blocking operations explicit + - Allows for Spark jobs to be lazily sequenced using monadic composition via for-comprehension + - Provides an obvious place where you can annotate/name your Spark jobs to make it easier + to track different parts of your application in the Spark UI

                        +

                        The toy example showcases the use of for-comprehension to explicitly sequences Spark Jobs. + First we calculate the size of the TypedDataset and then we collect to the driver + exactly 20% of its elements:

                        + 
                        import frameless.syntax._
+
+val ds = TypedDataset.create(1 to 20)
+// ds: TypedDataset[Int] = [value: int]
+
+val countAndTakeJob =
+  for {
+    count <- ds.count()
+    sample <- ds.take((count/5).toInt)
+  } yield sample
+// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@44e99d4f
+
+countAndTakeJob.run()
+// res1: Seq[Int] = WrappedArray(1, 2, 3, 4)
                        +

                        The countAndTakeJob can either be executed using run() (as we show above) or it can + be passed along to other parts of the program to be further composed into more complex sequences + of Spark jobs.

                        + 
                        import frameless.Job
+def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min)
+
+val finalJob = computeMinOfSample(countAndTakeJob)
+// finalJob: Job[Int] = frameless.Job$$anon$2@1ab7a43a
                        +

                        Now we can execute this new job by specifying a group-id and a description. + This allows the programmer to see this information on the Spark UI and help track, say, + performance issues.

                        + 
                        finalJob.
+  withGroupId("samplingJob").
+  withDescription("Samples 20% of elements and computes the min").
+  run()
+// res2: Int = 1
                        + +

                        More on SparkDelay

                        +

                        As mentioned above, SparkDelay[F[_]] is a typeclass required for suspending + effects by Spark computations. This typeclass represents the ability to suspend + an => A thunk into an F[A] value, while implicitly capturing a SparkSession.

                        +

                        As it is a typeclass, it is open for implementation by the user in order to use + other data types for suspension of effects. The cats module, for example, uses + this typeclass to support suspending Spark computations in any effect type that + has a cats.effect.Sync instance.

                        + +
                        - - - - - - - - - - - - -
                        - -
                        - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + \ No newline at end of file diff --git a/LICENSE b/LICENSE deleted file mode 100644 index 5c304d1a4..000000000 --- a/LICENSE +++ /dev/null @@ -1,201 +0,0 @@ -Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright {yyyy} {name of copyright owner} - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/README.md b/README.md deleted file mode 100644 index e5e734357..000000000 --- a/README.md +++ /dev/null @@ -1,142 +0,0 @@ -# Frameless - -[![Travis Badge](https://travis-ci.org/typelevel/frameless.svg?branch=master)](https://travis-ci.org/typelevel/frameless) -[![Codecov Badge](https://codecov.io/gh/typelevel/frameless/branch/master/graph/badge.svg)](https://codecov.io/gh/typelevel/frameless) -[![Maven Badge](https://img.shields.io/maven-central/v/org.typelevel/frameless-dataset_2.12.svg)](https://maven-badges.herokuapp.com/maven-central/org.typelevel/frameless-dataset_2.12) -[![Gitter Badge](https://badges.gitter.im/typelevel/frameless.svg)](https://gitter.im/typelevel/frameless) - -Frameless is a Scala library for working with [Spark](http://spark.apache.org/) using more expressive types. -It consists of the following modules: - -* `frameless-dataset` for a more strongly typed `Dataset`/`DataFrame` API -* `frameless-ml` for a more strongly typed Spark ML API based on `frameless-dataset` -* `frameless-cats` for using Spark's `RDD` API with [cats](https://github.com/typelevel/cats) - -Note that while Frameless is still getting off the ground, it is very possible that breaking changes will be -made for at least the next few versions. - -The Frameless project and contributors support the -[Typelevel](http://typelevel.org/) [Code of Conduct](http://typelevel.org/conduct.html) and want all its -associated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning. - - -## Versions and dependencies - -The compatible versions of [Spark](http://spark.apache.org/) and -[cats](https://github.com/typelevel/cats) are as follows: - -| Frameless | Spark | Cats | Cats-Effect | Scala | -| --- | --- | --- | --- | --- | -| 0.4.0 | 2.2.0 | 1.0.0-IF | 0.4 | 2.11 -| 0.4.1 | 2.2.0 | 1.x | 0.8 | 2.11 -| 0.5.2 | 2.2.1 | 1.x | 0.8 | 2.11 -| 0.6.1 | 2.3.0 | 1.x | 0.8 | 2.11 -| 0.7.0 | 2.3.1 | 1.x | 1.x | 2.11 -| 0.8.0 | 2.4.0 | 1.x | 1.x | 2.11/2.12 -| 0.9.0 | 3.0.0 | 1.x | 1.x | 2.12 - - -Versions 0.5.x and 0.6.x have identical features. The first is compatible with Spark 2.2.1 and the second with 2.3.0. - -The **only** dependency of the `frameless-dataset` module is on [shapeless](https://github.com/milessabin/shapeless) 2.3.2. -Therefore, depending on `frameless-dataset`, has a minimal overhead on your Spark's application jar. -Only the `frameless-cats` module depends on cats and cats-effect, so if you prefer to work just with `Datasets` and not with `RDD`s, -you may choose not to depend on `frameless-cats`. - -Frameless intentionally **does not** have a compile dependency on Spark. -This essentially allows you to use any version of Frameless with any version of Spark. -The aforementioned table simply provides the versions of Spark we officially compile -and test Frameless with, but other versions may probably work as well. - -### Breaking changes in 0.9 - -* Spark 3 introduces a new ExpressionEncoder approach, the schema for single value DataFrame's is now ["value"](https://github.com/apache/spark/blob/master/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/encoders/ExpressionEncoder.scala#L270) not "_1". - -## Why? - -Frameless introduces a new Spark API, called `TypedDataset`. -The benefits of using `TypedDataset` compared to the standard Spark `Dataset` API are as follows: - -* Typesafe columns referencing (e.g., no more runtime errors when accessing non-existing columns) -* Customizable, typesafe encoders (e.g., if a type does not have an encoder, it should not compile) -* Enhanced type signature for built-in functions (e.g., if you apply an arithmetic operation on a non-numeric column, you -get a compilation error) -* Typesafe casting and projections - -Click [here](http://typelevel.org/frameless/TypedDatasetVsSparkDataset.html) for a -detailed comparison of `TypedDataset` with Spark's `Dataset` API. - -## Documentation - -* [TypedDataset: Feature Overview](http://typelevel.org/frameless/FeatureOverview.html) -* [Typed Spark ML](http://typelevel.org/frameless/TypedML.html) -* [Comparing TypedDatasets with Spark's Datasets](http://typelevel.org/frameless/TypedDatasetVsSparkDataset.html) -* [Typed Encoders in Frameless](http://typelevel.org/frameless/TypedEncoder.html) -* [Injection: Creating Custom Encoders](http://typelevel.org/frameless/Injection.html) -* [Job\[A\]](http://typelevel.org/frameless/Job.html) -* [Using Cats with RDDs](http://typelevel.org/frameless/Cats.html) -* [Proof of Concept: TypedDataFrame](http://typelevel.org/frameless/TypedDataFrame.html) - -## Quick Start -Since the 0.9.x release, Frameless is compiled only against Scala 2.12.x. - -To use Frameless in your project add the following in your `build.sbt` file as needed: - -```scala -val framelessVersion = "0.9.0" // for Spark 3.0.0 - -libraryDependencies ++= List( - "org.typelevel" %% "frameless-dataset" % framelessVersion, - "org.typelevel" %% "frameless-ml" % framelessVersion, - "org.typelevel" %% "frameless-cats" % framelessVersion -) -``` - -An easy way to bootstrap a Frameless sbt project: - -- if you have [Giter8][g8] installed then simply: - -```bash -g8 imarios/frameless.g8 -``` -- with sbt >= 0.13.13: - -```bash -sbt new imarios/frameless.g8 -``` - -Typing `sbt console` inside your project will bring up a shell with Frameless -and all its dependencies loaded (including Spark). - -## Need help? - -Feel free to messages us on our [gitter](https://gitter.im/typelevel/frameless) -channel for any issues/questions. - - -## Development -We require at least *one* sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers -(people who can merge pull requests) are: - -* [adelbertc](https://github.com/adelbertc) -* [imarios](https://github.com/imarios) -* [kanterov](https://github.com/kanterov) -* [non](https://github.com/non) -* [OlivierBlanvillain](https://github.com/OlivierBlanvillain/) - -### Testing - -Frameless contains several property tests. To avoid `OutOfMemoryError`s, we -tune the default generator sizes. The following environment variables may -be set to adjust the size of generated collections in the `TypedDataSet` suite: - -| Property | Default | -|-----------------------------|--------:| -| FRAMELESS_GEN_MIN_SIZE | 0 | -| FRAMELESS_GEN_SIZE_RANGE | 20 | - -## License -Code is provided under the Apache 2.0 license available at http://opensource.org/licenses/Apache-2.0, -as well as in the LICENSE file. This is the same license used as Spark. - -[g8]: http://www.foundweekends.org/giter8/ diff --git a/TypedDataFrame.html b/TypedDataFrame.html index e889ffad4..120ae7e62 100644 --- a/TypedDataFrame.html +++ b/TypedDataFrame.html @@ -1,430 +1,196 @@ - - - - - - - Proof of Concept: TypedDataFrame · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + Proof of Concept: TypedDataFrame - - + - - - - - + - - - - - - - + + + + - + + - - - -
                        -
                        - - - + - - - - -
                        - -
                        -
                        - - - - - - - - -
                        -
                        - -
                        -
                        - -
                        - -

                        Proof of Concept: TypedDataFrame

                        -

                        TypedDataFrame is the API developed in the early stages of Frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future development of Frameless. However, the design is interesting enough to document.

                        -

                        To safely manipulate DataFrames we use a technique called a shadow type, which consists in storing additional information about a value in a "dummy" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.

                        -

                        Diving in

                        -

                        In TypedDataFrame, we use a single Schema <: Product to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:

                        -
                        import org.apache.spark.sql.DataFrame
-import shapeless.HList
-
-class TDataFrame[Schema <: Product](df: DataFrame) {
-  def filter(predicate: Schema => Boolean): TDataFrame[Schema] = ???
-
-  def select[C <: HList, Out <: Product](columns: C): TDataFrame[Out] = ???
-
-  def innerJoin[OtherS <: Product, Out <: Product]
-    (other: TDataFrame[OtherS]): TDataFrame[Out] = ???
-
-  // Followed by equivalent of every DataFrame method with improved signature
-}
-
                        -

                        As you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.

                        -

                        Type-level column referencing

                        -

                        For Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching invalid column references compile type. When everything goes well, Frameless select is very similar to vanilla select, except that it keeps track of the selected column types:

                        -
                        import frameless.TypedDataFrame
-
-case class Foo(s: String, d: Double, i: Int)
-
-def selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =
-  tf.select('i, 's)
-
                        -

                        However, in case of typo, it gets caught right away:

                        -
                        def selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =
-  tf.select('j, 's)
-
                        -

                        Type-level joins

                        -

                        Joins can available with two different syntaxes. The first lets you reference different columns on each TypedDataFrame, and ensures that they all exist and have compatible types:

                        -
                        case class Bar(i: Int, j: String, b: Boolean)
-
-def join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])
-    : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =
-  tf1.innerJoin(tf2).on('s).and('j)
-
                        -

                        The second syntax brings some convenience when the joining columns have identical names in both tables:

                        -
                        def join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])
-    : TypedDataFrame[(String, Double, Int, String, Boolean)] =
-  tf1.innerJoin(tf2).using('i)
-
                        -

                        Further example are available in the TypedDataFrame join tests.

                        -

                        Complete example

                        -

                        We now consider a complete example to see how the Frameless types can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city maps and neighborhoods:

                        -
                        type Neighborhood = String
-type Address = String
-
-case class PhoneBookEntry(
-  address: Address,
-  residents: String,
-  phoneNumber: Double
-)
-
-case class CityMapEntry(
-  address: Address,
-  neighborhood: Neighborhood
-)
-
                        -

                        Our goal will be to compute the neighborhood with unique names, approximating "unique" with names containing less common -letters in the alphabet: 'x', 'q', and 'z'. We are going to need a natural language processing library at some point, so -let's use the following for the example:

                        -
                        object NLPLib {
-  def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))
-}
-
                        -

                        Suppose we manage to obtain public data for a TypedDataFrame[PhoneBookEntry] and TypedDataFrame[CityMapEntry]. Here is what our Spark job could look like with Frameless:

                        -
                        import org.apache.spark.sql.SQLContext
-
-// These case classes are used to hold intermediate results
-case class Family(residents: String, neighborhood: Neighborhood)
-case class Person(name: String, neighborhood: Neighborhood)
-case class NeighborhoodCount(neighborhood: Neighborhood, count: Long)
-
-def bestNeighborhood
-  (phoneBookTF: TypedDataFrame[PhoneBookEntry], cityMapTF: TypedDataFrame[CityMapEntry])
-  (implicit c: SQLContext): String = {
+
                        + + + + + + + + + + + + + +
                        + + + +
                        + +

                        Proof of Concept: TypedDataFrame

                        +

                        TypedDataFrame is the API developed in the early stages of Frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future development of Frameless. However, the design is interesting enough to document.

                        +

                        To safely manipulate DataFrames we use a technique called a shadow type, which consists in storing additional information about a value in a "dummy" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.

                        + +

                        Diving in

                        +

                        In TypedDataFrame, we use a single Schema <: Product to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:

                        + 
                        import org.apache.spark.sql.DataFrame
+import shapeless.HList
+
+class TDataFrame[Schema <: Product](df: DataFrame) {
+  def filter(predicate: Schema => Boolean): TDataFrame[Schema] = ???
+
+  def select[C <: HList, Out <: Product](columns: C): TDataFrame[Out] = ???
+
+  def innerJoin[OtherS <: Product, Out <: Product]
+    (other: TDataFrame[OtherS]): TDataFrame[Out] = ???
+
+  // Followed by equivalent of every DataFrame method with improved signature
+}
                        +

                        As you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.

                        + +

                        Type-level column referencing

                        +

                        For Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching invalid column references compile type. When everything goes well, Frameless select is very similar to vanilla select, except that it keeps track of the selected column types:

                        + 
                        import frameless.TypedDataFrame
+
+case class Foo(s: String, d: Double, i: Int)
+
+def selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =
+  tf.select('i, 's)
                        +

                        However, in case of typo, it gets caught right away:

                        + 
                        def selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =
+  tf.select('j, 's)
                        + +

                        Type-level joins

                        +

                        Joins can available with two different syntaxes. The first lets you reference different columns on each TypedDataFrame, and ensures that they all exist and have compatible types:

                        + 
                        case class Bar(i: Int, j: String, b: Boolean)
+
+def join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])
+    : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =
+  tf1.innerJoin(tf2).on('s).and('j)
                        +

                        The second syntax brings some convenience when the joining columns have identical names in both tables:

                        + 
                        def join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])
+    : TypedDataFrame[(String, Double, Int, String, Boolean)] =
+  tf1.innerJoin(tf2).using('i)
                        +

                        Further example are available in the TypedDataFrame join tests.

                        + +

                        Complete example

                        +

                        We now consider a complete example to see how the Frameless types can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city maps and neighborhoods:

                        + 
                        type Neighborhood = String
+type Address = String
+
+case class PhoneBookEntry(
+  address: Address,
+  residents: String,
+  phoneNumber: Double
+)
+
+case class CityMapEntry(
+  address: Address,
+  neighborhood: Neighborhood
+)
                        +

                        Our goal will be to compute the neighborhood with unique names, approximating "unique" with names containing less common + letters in the alphabet: 'x', 'q', and 'z'. We are going to need a natural language processing library at some point, so + let's use the following for the example:

                        + 
                        object NLPLib {
+  def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))
+}
                        +

                        Suppose we manage to obtain public data for a TypedDataFrame[PhoneBookEntry] and TypedDataFrame[CityMapEntry]. Here is what our Spark job could look like with Frameless:

                        + 
                        import org.apache.spark.sql.SQLContext
+
+// These case classes are used to hold intermediate results
+case class Family(residents: String, neighborhood: Neighborhood)
+case class Person(name: String, neighborhood: Neighborhood)
+case class NeighborhoodCount(neighborhood: Neighborhood, count: Long)
+
+def bestNeighborhood
+  (phoneBookTF: TypedDataFrame[PhoneBookEntry], cityMapTF: TypedDataFrame[CityMapEntry])
+  (implicit c: SQLContext): String = {
                                           (((((((((
-  phoneBookTF
-    .innerJoin(cityMapTF).using('address) :TypedDataFrame[(Address, String, Double, String)])
-    .select('_2, '_4)                     :TypedDataFrame[(String, String)])
-    .as[Family]()                         :TypedDataFrame[Family])
-    .flatMap { f =>
-      f.residents.split(' ').map(r => Person(r, f.neighborhood))
-    }                                     :TypedDataFrame[Person])
-    .filter { p =>
-      NLPLib.uniqueName(p.name)
-    }                                     :TypedDataFrame[Person])
-    .groupBy('neighborhood).count()       :TypedDataFrame[(String, Long)])
-    .as[NeighborhoodCount]()              :TypedDataFrame[NeighborhoodCount])
-    .sortDesc('count)                     :TypedDataFrame[NeighborhoodCount])
-    .select('neighborhood)                :TypedDataFrame[Tuple1[String]])
-    .head._1
-}
-
                        -

                        If you compare this version to vanilla Spark where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.

                        -

                        Limitations

                        -

                        The main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.

                        -

                        In the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in Frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.

                        - - - - -
                        -
                        -
                        - -

                        results matching ""

                        -
                          - -
                          -
                          - -

                          No results matching ""

                          - -
                          -
                          -
                          + phoneBookTF + .innerJoin(cityMapTF).using('address) :TypedDataFrame[(Address, String, Double, String)]) + .select('_2, '_4) :TypedDataFrame[(String, String)]) + .as[Family]() :TypedDataFrame[Family]) + .flatMap { f => + f.residents.split(' ').map(r => Person(r, f.neighborhood)) + } :TypedDataFrame[Person]) + .filter { p => + NLPLib.uniqueName(p.name) + } :TypedDataFrame[Person]) + .groupBy('neighborhood).count() :TypedDataFrame[(String, Long)]) + .as[NeighborhoodCount]() :TypedDataFrame[NeighborhoodCount]) + .sortDesc('count) :TypedDataFrame[NeighborhoodCount]) + .select('neighborhood) :TypedDataFrame[Tuple1[String]]) + .head._1 +} +

                          If you compare this version to vanilla Spark where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.

                          + +

                          Limitations

                          +

                          The main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.

                          +

                          In the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in Frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.

                          + + -
                          -
                          - -
                          - - - - - - - - - -
                          - -
                          - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + \ No newline at end of file diff --git a/TypedDatasetVsSparkDataset.html b/TypedDatasetVsSparkDataset.html index a35a2664e..f9e72916d 100644 --- a/TypedDatasetVsSparkDataset.html +++ b/TypedDatasetVsSparkDataset.html @@ -1,664 +1,411 @@ - - - - - - - Comparing TypedDatasets with Spark's Datasets · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + Comparing TypedDatasets with Spark's Datasets - - - - - - - - - + - - - - - -
                          -
                          - - - - - - - -
                          - -
                          +
                          + + + + + + + + + + + + + +
                          + +
                          - - -
                          - - - - - - - - - + - +

                          + + +
                          + +

                          Comparing TypedDatasets with Spark's Datasets

                          +

                          Goal: + This tutorial compares the standard Spark Datasets API with the one provided by + Frameless' TypedDataset. It shows how TypedDatasets allow for an expressive and + type-safe api with no compromises on performance.

                          +

                          For this tutorial we first create a simple dataset and save it on disk as a parquet file. + Parquet is a popular columnar format and well supported by Spark. + It's important to note that when operating on parquet datasets, Spark knows that each column is stored + separately, so if we only need a subset of the columns Spark will optimize for this and avoid reading + the entire dataset. This is a rather simplistic view of how Spark and parquet work together but it + will serve us well for the context of this discussion.

                          + 
                          import spark.implicits._
+
+// Our example case class Foo acting here as a schema
+case class Foo(i: Long, j: String)
+
+// Assuming spark is loaded and SparkSession is bind to spark
+val initialDs = spark.createDataset( Foo(1, "Q") :: Foo(10, "W") :: Foo(100, "E") :: Nil )
+// initialDs: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]
+
+// Assuming you are on Linux or Mac OS
+initialDs.write.parquet("/tmp/foo")
+
+val ds = spark.read.parquet("/tmp/foo").as[Foo]
+// ds: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]
+
+ds.show()
+// +---+---+
+// |  i|  j|
+// +---+---+
+// | 10|  W|
+// |100|  E|
+// |  1|  Q|
+// +---+---+
+//
                          +

                          The value ds holds the content of the initialDs read from a parquet file. + Let's try to only use field i from Foo and see how Spark's Catalyst (the query optimizer) + optimizes this.

                          + 
                          // Using a standard Spark TypedColumn in select()
+val filteredDs = ds.filter($"i" === 10).select($"i".as[Long])
+// filteredDs: org.apache.spark.sql.Dataset[Long] = [i: bigint]
+
+filteredDs.show()
+// +---+
+// |  i|
+// +---+
+// | 10|
+// +---+
+//
                          +

                          The filteredDs is of type Dataset[Long]. Since we only access field i from Foo the type is correct. + Unfortunately, this syntax requires handholding by explicitly setting the TypedColumn in the select statement + to return type Long (look at the as[Long] statement). We will discuss this limitation next in more detail. + Now, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.

                          + 
                          filteredDs.explain()
+// == Physical Plan ==
+// *(1) Filter (isnotnull(i#2063L) AND (i#2063L = 10))
+// +- *(1) ColumnarToRow
+//    +- FileScan parquet [i#2063L] Batched: true, DataFilters: [isnotnull(i#2063L), (i#2063L = 10)], Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct<i:bigint>
+// 
+//
                          +

                          The last line is very important (see ReadSchema). The schema read + from the parquet file only required reading column i without needing to access column j. + This is great! We have both an optimized query plan and type-safety!

                          +

                          Unfortunately, this syntax is not bulletproof: it fails at run-time if we try to access + a non existing column x:

                          + 
                          ds.filter($"i" === 10).select($"x".as[Long])
+// org.apache.spark.sql.AnalysisException: cannot resolve 'x' given input columns: [i, j];
+// 'Project ['x]
+// +- Filter (i#2063L = cast(10 as bigint))
+//    +- Relation [i#2063L,j#2064] parquet
+// 
+// 	at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:54)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:179)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:175)
+// 	at org.apache.spark.sql.catalyst.trees.TreeNode.$anonfun$transformUpWithPruning$2(TreeNode.scala:535)
+// 	at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:82)
+// 	at org.apache.spark.sql.catalyst.trees.TreeNode.transformUpWithPruning(TreeNode.scala:535)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$transformExpressionsUpWithPruning$1(QueryPlan.scala:181)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$1(QueryPlan.scala:193)
+// 	at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:82)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:193)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:204)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$3(QueryPlan.scala:209)
+// 	at scala.collection.TraversableLike.$anonfun$map$1(TraversableLike.scala:286)
+// 	at scala.collection.immutable.List.foreach(List.scala:431)
+// 	at scala.collection.TraversableLike.map(TraversableLike.scala:286)
+// 	at scala.collection.TraversableLike.map$(TraversableLike.scala:279)
+// 	at scala.collection.immutable.List.map(List.scala:305)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:209)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$4(QueryPlan.scala:214)
+// 	at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:323)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:214)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUpWithPruning(QueryPlan.scala:181)
+// 	at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:161)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1(CheckAnalysis.scala:175)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1$adapted(CheckAnalysis.scala:94)
+// 	at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:263)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:94)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:91)
+// 	at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:172)
+// 	at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:195)
+// 	at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:330)
+// 	at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:192)
+// 	at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:88)
+// 	at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)
+// 	at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:196)
+// 	at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:775)
+// 	at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:196)
+// 	at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:88)
+// 	at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:86)
+// 	at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:78)
+// 	at org.apache.spark.sql.Dataset.<init>(Dataset.scala:205)
+// 	at org.apache.spark.sql.Dataset.<init>(Dataset.scala:211)
+// 	at org.apache.spark.sql.Dataset.select(Dataset.scala:1509)
+// 	at repl.MdocSession$App0$$anonfun$15.apply(TypedDatasetVsSparkDataset.md:78)
+// 	at repl.MdocSession$App0$$anonfun$15.apply(TypedDatasetVsSparkDataset.md:78)
                          +

                          There are two things to improve here. First, we would want to avoid the as[Long] casting that we are required + to type for type-safety. This is clearly an area where we may introduce a bug by casting to an incompatible + type. Second, we want a solution where reference to a non existing column name fails at compilation time. + The standard Spark Dataset can achieve this using the following syntax.

                          + 
                          ds.filter(_.i == 10).map(_.i).show()
+// +-----+
+// |value|
+// +-----+
+// |   10|
+// +-----+
+//
                          +

                          This looks great! It reminds us the familiar syntax from Scala. + The two closures in filter and map are functions that operate on Foo and the + compiler will helps us capture all the mistakes we mentioned above.

                          + 
                          ds.filter(_.i == 10).map(_.x).show()
+// error: value x is not a member of repl.MdocSession.App0.Foo
+// ds.filter(_.i == 10).map(_.x).show()
+//                          ^^^
                          +

                          Unfortunately, this syntax does not allow Spark to optimize the code.

                          + 
                          ds.filter(_.i == 10).map(_.i).explain()
+// == Physical Plan ==
+// *(1) SerializeFromObject [input[0, bigint, false] AS value#2114L]
+// +- *(1) MapElements <function1>, obj#2113: bigint
+//    +- *(1) Filter <function1>.apply
+//       +- *(1) DeserializeToObject newInstance(class repl.MdocSession$App0$Foo), obj#2112: repl.MdocSession$App0$Foo
+//          +- *(1) ColumnarToRow
+//             +- FileScan parquet [i#2063L,j#2064] Batched: true, DataFilters: [], Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/tmp/foo], PartitionFilters: [], PushedFilters: [], ReadSchema: struct<i:bigint,j:string>
+// 
+//
                          +

                          As we see from the explained Physical Plan, Spark was not able to optimize our query as before. + Reading the parquet file will required loading all the fields of Foo. This might be ok for + small datasets or for datasets with few columns, but will be extremely slow for most practical + applications. Intuitively, Spark currently does not have a way to look inside the code we pass in these two + closures. It only knows that they both take one argument of type Foo, but it has no way of knowing if + we use just one or all of Foo's fields.

                          +

                          The TypedDataset in Frameless solves this problem. It allows for a simple and type-safe syntax + with a fully optimized query plan.

                          + 
                          import frameless.TypedDataset
+import frameless.syntax._
+val fds = TypedDataset.create(ds)
+// fds: TypedDataset[Foo] = [i: bigint, j: string]
+
+fds.filter(fds('i) === 10).select(fds('i)).show().run()
+// +-----+
+// |value|
+// +-----+
+// |   10|
+// +-----+
+//
                          +

                          And the optimized Physical Plan:

                          + 
                          fds.filter(fds('i) === 10).select(fds('i)).explain()
+// == Physical Plan ==
+// *(1) Project [i#2063L AS value#2198L]
+// +- *(1) Filter (isnotnull(i#2063L) AND (i#2063L = 10))
+//    +- *(1) ColumnarToRow
+//       +- FileScan parquet [i#2063L] Batched: true, DataFilters: [isnotnull(i#2063L), (i#2063L = 10)], Format: Parquet, Location: InMemoryFileIndex(1 paths)[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct<i:bigint>
+// 
+//
                          +

                          And the compiler is our friend.

                          + 
                          fds.filter(fds('i) === 10).select(fds('x))
+// error: No column Symbol with shapeless.tag.Tagged[String("x")] of type A in repl.MdocSession.App0.Foo
+// fds.filter(fds('i) === 10).select(fds('x))
+//                                      ^
                          - - - - - - - - - +

                          Differences in Encoders

                          +

                          Encoders in Spark's Datasets are partially type-safe. If you try to create a Dataset using a type that is not + a Scala Product then you get a compilation error:

                          + 
                          class Bar(i: Int)
                          +

                          Bar is neither a case class nor a Product, so the following correctly gives a compilation error in Spark:

                          + 
                          spark.createDataset(Seq(new Bar(1)))
+// error: Unable to find encoder for type repl.MdocSession.App0.Bar. An implicit Encoder[repl.MdocSession.App0.Bar] is needed to store repl.MdocSession.App0.Bar instances in a Dataset. Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._  Support for serializing other types will be added in future releases.
+// spark.createDataset(Seq(new Bar(1)))
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                          +

                          However, the compile type guards implemented in Spark are not sufficient to detect non encodable members. + For example, using the following case class leads to a runtime failure:

                          + 
                          case class MyDate(jday: java.util.Date)
                          + 
                          val myDateDs = spark.createDataset(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))
+// java.lang.UnsupportedOperationException: No Encoder found for java.util.Date
+// - field (class: "java.util.Date", name: "jday")
+// - root class: "repl.MdocSession.App0.MyDate"
+// 	at org.apache.spark.sql.errors.QueryExecutionErrors$.cannotFindEncoderForTypeError(QueryExecutionErrors.scala:1000)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:617)
+// 	at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:947)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:946)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:51)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:448)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$6(ScalaReflection.scala:604)
+// 	at scala.collection.immutable.List.map(List.scala:293)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:589)
+// 	at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:947)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:946)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:51)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:448)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerForType$1(ScalaReflection.scala:437)
+// 	at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:947)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:946)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:51)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.serializerForType(ScalaReflection.scala:429)
+// 	at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:55)
+// 	at org.apache.spark.sql.Encoders$.product(Encoders.scala:300)
+// 	at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder(SQLImplicits.scala:261)
+// 	at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder$(SQLImplicits.scala:261)
+// 	at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:32)
+// 	at repl.MdocSession$App0$$anonfun$41.apply$mcV$sp(TypedDatasetVsSparkDataset.md:151)
+// 	at repl.MdocSession$App0$$anonfun$41.apply(TypedDatasetVsSparkDataset.md:150)
+// 	at repl.MdocSession$App0$$anonfun$41.apply(TypedDatasetVsSparkDataset.md:150)
                          +

                          In comparison, a TypedDataset will notify about the encoding problem at compile time:

                          + 
                          TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))
+// error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.MyDate]
+// TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                          - - - - - - - +

                          Aggregate vs Projected columns

                          +

                          Spark's Dataset do not distinguish between columns created from aggregate operations, + such as summing or averaging, and simple projections/selections. + This is problematic when you start mixing the two.

                          + 
                          import org.apache.spark.sql.functions.sum
                          + 
                          ds.select(sum($"i"), $"i"*2)
+// org.apache.spark.sql.AnalysisException: grouping expressions sequence is empty, and 'i' is not an aggregate function. Wrap '(sum(i) AS `sum(i)`)' in windowing function(s) or wrap 'i' in first() (or first_value) if you don't care which value you get.;
+// Aggregate [sum(i#2063L) AS sum(i)#2204L, (i#2063L * cast(2 as bigint)) AS (i * 2)#2205L]
+// +- Relation [i#2063L,j#2064] parquet
+// 
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.failAnalysis(CheckAnalysis.scala:51)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.failAnalysis$(CheckAnalysis.scala:50)
+// 	at org.apache.spark.sql.catalyst.analysis.Analyzer.failAnalysis(Analyzer.scala:172)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkValidAggregateExpression$1(CheckAnalysis.scala:296)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$13(CheckAnalysis.scala:311)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$13$adapted(CheckAnalysis.scala:311)
+// 	at scala.collection.Iterator.foreach(Iterator.scala:943)
+// 	at scala.collection.Iterator.foreach$(Iterator.scala:943)
+// 	at scala.collection.AbstractIterator.foreach(Iterator.scala:1431)
+// 	at scala.collection.IterableLike.foreach(IterableLike.scala:74)
+// 	at scala.collection.IterableLike.foreach$(IterableLike.scala:73)
+// 	at scala.collection.AbstractIterable.foreach(Iterable.scala:56)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkValidAggregateExpression$1(CheckAnalysis.scala:311)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$13(CheckAnalysis.scala:311)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$13$adapted(CheckAnalysis.scala:311)
+// 	at scala.collection.Iterator.foreach(Iterator.scala:943)
+// 	at scala.collection.Iterator.foreach$(Iterator.scala:943)
+// 	at scala.collection.AbstractIterator.foreach(Iterator.scala:1431)
+// 	at scala.collection.IterableLike.foreach(IterableLike.scala:74)
+// 	at scala.collection.IterableLike.foreach$(IterableLike.scala:73)
+// 	at scala.collection.AbstractIterable.foreach(Iterable.scala:56)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkValidAggregateExpression$1(CheckAnalysis.scala:311)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$16(CheckAnalysis.scala:338)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$16$adapted(CheckAnalysis.scala:338)
+// 	at scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)
+// 	at scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)
+// 	at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1(CheckAnalysis.scala:338)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1$adapted(CheckAnalysis.scala:94)
+// 	at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:263)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:94)
+// 	at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:91)
+// 	at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:172)
+// 	at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:195)
+// 	at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:330)
+// 	at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:192)
+// 	at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:88)
+// 	at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)
+// 	at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:196)
+// 	at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:775)
+// 	at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:196)
+// 	at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:88)
+// 	at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:86)
+// 	at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:78)
+// 	at org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:90)
+// 	at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:775)
+// 	at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:88)
+// 	at org.apache.spark.sql.Dataset.withPlan(Dataset.scala:3734)
+// 	at org.apache.spark.sql.Dataset.select(Dataset.scala:1454)
+// 	at repl.MdocSession$App0$$anonfun$44.apply(TypedDatasetVsSparkDataset.md:173)
+// 	at repl.MdocSession$App0$$anonfun$44.apply(TypedDatasetVsSparkDataset.md:173)
                          +

                          In Frameless, mixing the two results in a compilation error.

                          + 
                          // To avoid confusing frameless' sum with the standard Spark's sum
+import frameless.functions.aggregate.{sum => fsum}
                          + 
                          fds.select(fsum(fds('i)))
+// error: polymorphic expression cannot be instantiated to expected type;
+//  found   : [Out]frameless.TypedAggregate[repl.MdocSession.App0.Foo,Out]
+//  required: frameless.TypedColumn[repl.MdocSession.App0.Foo,?]
+// fds.select(fsum(fds('i)))
+//            ^^^^^^^^^^^^^
                          +

                          As the error suggests, we expected a TypedColumn but we got a TypedAggregate instead.

                          +

                          Here is how you apply an aggregation method in Frameless:

                          + 
                          fds.agg(fsum(fds('i))+22).show().run()
+// +-----+
+// |value|
+// +-----+
+// |  133|
+// +-----+
+//
                          +

                          Similarly, mixing projections while aggregating does not make sense, and in Frameless + you get a compilation error.

                          + 
                          fds.agg(fsum(fds('i)), fds('i)).show().run()
+// error: polymorphic expression cannot be instantiated to expected type;
+//  found   : [A]frameless.TypedColumn[repl.MdocSession.App0.Foo,A]
+//  required: frameless.TypedAggregate[repl.MdocSession.App0.Foo,?]
+// fds.agg(fsum(fds('i)), fds('i)).show().run()
+//                        ^^^^^^^
                          + +
                          - - + + + \ No newline at end of file diff --git a/TypedEncoder.html b/TypedEncoder.html index f25487898..4a088fee8 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -1,404 +1,162 @@ - - - - - - - Typed Encoders in Frameless · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + Typed Encoders in Frameless - - - - - - - - - - - - - - - - - -
                          -
                          - - - - - - - - -
                          - -
                          -
                          - - - - + + + + + + + + + + + + + +
                          + + + +
                          + +

                          Typed Encoders in Frameless

                          +

                          Spark uses Reflection to derive its Encoders, which is why they can fail at run time. For example, because Spark does not support java.util.Date, the following leads to an error:

                          + 
                          import org.apache.spark.sql.Dataset
+import spark.implicits._
+
+case class DateRange(s: java.util.Date, e: java.util.Date)
                          + 
                          val ds: Dataset[DateRange] = Seq(DateRange(new java.util.Date, new java.util.Date)).toDS()
+// java.lang.UnsupportedOperationException: No Encoder found for java.util.Date
+// - field (class: "java.util.Date", name: "s")
+// - root class: "repl.MdocSession.App0.DateRange"
+// 	at org.apache.spark.sql.errors.QueryExecutionErrors$.cannotFindEncoderForTypeError(QueryExecutionErrors.scala:1000)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:617)
+// 	at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:947)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:946)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:51)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:448)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$6(ScalaReflection.scala:604)
+// 	at scala.collection.immutable.List.map(List.scala:293)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:589)
+// 	at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:947)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:946)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:51)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:448)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerForType$1(ScalaReflection.scala:437)
+// 	at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:947)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:946)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:51)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.serializerForType(ScalaReflection.scala:429)
+// 	at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:55)
+// 	at org.apache.spark.sql.Encoders$.product(Encoders.scala:300)
+// 	at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder(SQLImplicits.scala:261)
+// 	at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder$(SQLImplicits.scala:261)
+// 	at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:32)
+// 	at repl.MdocSession$App0$$anonfun$4.apply$mcV$sp(TypedEncoder.md:45)
+// 	at repl.MdocSession$App0$$anonfun$4.apply(TypedEncoder.md:44)
+// 	at repl.MdocSession$App0$$anonfun$4.apply(TypedEncoder.md:44)
                          +

                          As shown by the stack trace, this runtime error goes through ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection-based approach is its inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.

                          +

                          Frameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every Frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless' type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the java.util.Date example won't compile with Frameless:

                          + 
                          import frameless.TypedDataset
+import frameless.syntax._
                          + 
                          val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))
+// error: ds is already defined as value ds
+// val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))
+//     ^^
+// error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.DateRange]
+// val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))
+//                                                      ^
                          +

                          Type class derivation takes care of recursively constructing (and proving the existence of) TypeEncoders for case classes. The following works as expected:

                          + 
                          case class Bar(d: Double, s: String)
+case class Foo(i: Int, b: Bar)
+val ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s"))))
+// ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>]
+ds.collect()
+// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@3d8cdc0a
                          +

                          But any non-encodable in the case class hierarchy will be detected at compile time:

                          + 
                          case class BarDate(d: Double, s: String, t: java.util.Date)
+case class FooDate(i: Int, b: BarDate)
                          + 
                          val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, "s", new java.util.Date))))
+// error: ds is already defined as value ds
+// val ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s"))))
+//     ^^
+// error: ds is already defined as value ds
+// val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, "s", new java.util.Date))))
+//     ^^
+// error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.FooDate]
+// val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, "s", new java.util.Date))))
+//                                                    ^
                          +

                          It should be noted that once derived, reflection-based Encoders and implicitly derived TypeEncoders have identical performance. The derivation mechanism is different, but the objects generated to encode and decode JVM objects in Spark's internal representation behave the same at runtime.

                          + +
                          - -

                          - - Typed Encoders in Frameless -

                          -
                          - - - - -
                          -
                          - -
                          -
                          - -
                          - -

                          Typed Encoders in Frameless

                          -

                          Spark uses Reflection to derive its Encoders, which is why they can fail at run time. For example, because Spark does not support java.util.Date, the following leads to an error:

                          -
                          import org.apache.spark.sql.Dataset
-import spark.implicits._
-
-case class DateRange(s: java.util.Date, e: java.util.Date)
-
                          -
                          scala> val ds: Dataset[DateRange] = Seq(DateRange(new java.util.Date, new java.util.Date)).toDS()
-java.lang.UnsupportedOperationException: No Encoder found for java.util.Date
-- field (class: "java.util.Date", name: "s")
-- root class: "DateRange"
-  at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:591)
-  at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)
-  at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)
-  at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)
-  at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)
-  at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432)
-  at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$6(ScalaReflection.scala:577)
-  at scala.collection.immutable.List.map(List.scala:293)
-  at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:562)
-  at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)
-  at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)
-  at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)
-  at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)
-  at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432)
-  at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerForType$1(ScalaReflection.scala:421)
-  at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)
-  at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)
-  at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)
-  at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)
-  at org.apache.spark.sql.catalyst.ScalaReflection$.serializerForType(ScalaReflection.scala:413)
-  at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:56)
-  at org.apache.spark.sql.Encoders$.product(Encoders.scala:285)
-  at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder(SQLImplicits.scala:251)
-  at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder$(SQLImplicits.scala:251)
-  at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:32)
-  ... 42 elided
-
                          -

                          As shown by the stack trace, this runtime error goes through ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection-based approach is its inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.

                          -

                          Frameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every Frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless' type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the java.util.Date example won't compile with Frameless:

                          -
                          import frameless.TypedDataset
-import frameless.syntax._
-
                          -
                          val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))
-// <console>:28: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]
-//        val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))
-//                                                             ^
-
                          -

                          Type class derivation takes care of recursively constructing (and proving the existence of) TypeEncoders for case classes. The following works as expected:

                          -
                          case class Bar(d: Double, s: String)
-// defined class Bar
-
-case class Foo(i: Int, b: Bar)
-// defined class Foo
-
-val ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s"))))
-// ds: frameless.TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>]
-
-ds.collect()
-// res1: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@77bca0d3
-
                          -

                          But any non-encodable in the case class hierarchy will be detected at compile time:

                          -
                          case class BarDate(d: Double, s: String, t: java.util.Date)
-case class FooDate(i: Int, b: BarDate)
-
                          -
                          val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, "s", new java.util.Date))))
-// <console>:30: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]
-//        val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, "s", new java.util.Date))))
-//                                                           ^
-
                          -

                          It should be noted that once derived, reflection-based Encoders and implicitly derived TypeEncoders have identical performance. The derivation mechanism is different, but the objects generated to encode and decode JVM objects in Spark's internal representation behave the same at runtime.

                          - - -
                          -
                          -
                          -
                          - -

                          results matching ""

                          -
                            - -
                            -
                            - -

                            No results matching ""

                            - -
                            -
                            -
                            - -
                            -
                            - -
                            - - - - - - - - - - - - - - -
                            - - -
                            - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + \ No newline at end of file diff --git a/TypedML.html b/TypedML.html index 568b50247..43c901789 100644 --- a/TypedML.html +++ b/TypedML.html @@ -1,641 +1,355 @@ - - - - - - - Using Spark ML with TypedDataset · GitBook - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                            -
                            - - - - - - - - -
                            - -
                            - -
                            - - - - - - - - -
                            -
                            - -
                            -
                            - -
                            - -

                            Typed Spark ML

                            -

                            The frameless-ml module provides a strongly typed Spark ML API leveraging TypedDatasets. It introduces TypedTransformers -and TypedEstimators, the type-safe equivalents of Spark ML's Transformer and Estimator.

                            -

                            A TypedEstimator fits models to data, i.e trains a ML model based on an input TypedDataset. -A TypedTransformer transforms one TypedDataset into another, usually by appending column(s) to it.

                            -

                            By calling the fit method of a TypedEstimator, the TypedEstimator will train a ML model using the TypedDataset -passed as input (representing the training data) and will return a TypedTransformer that represents the trained model. -This TypedTransformercan then be used to make predictions on an input TypedDataset (representing the test data) -using the transform method that will return a new TypedDataset with appended prediction column(s).

                            -

                            Both TypedEstimator and TypedTransformer check at compile-time the correctness of their inputs field names and types, -contrary to Spark ML API which only deals with DataFrames (the data structure with the lowest level of type-safety in Spark).

                            -

                            frameless-ml adds type-safety to Spark ML API but stays very close to it in terms of abstractions and API calls, so -please check Spark ML documentation for more details -on Transformers and Estimators.

                            -

                            Example 1: predict a continuous value using a TypedRandomForestRegressor

                            -

                            In this example, we want to predict the sale price of a house depending on its square footage and the fact that the house -has a garden or not. We will use a TypedRandomForestRegressor.

                            -

                            Training

                            -

                            As with the Spark ML API, we use a TypedVectorAssembler (the type-safe equivalent of VectorAssembler) -to compute feature vectors:

                            -
                            import frameless._
-import frameless.syntax._
-import frameless.ml._
-import frameless.ml.feature._
-import frameless.ml.regression._
-import org.apache.spark.ml.linalg.Vector
-
                            -
                            case class HouseData(squareFeet: Double, hasGarden: Boolean, price: Double)
-// defined class HouseData
-
-val trainingData = TypedDataset.create(Seq(
-  HouseData(20, false, 100000),
-  HouseData(50, false, 200000),
-  HouseData(50, true, 250000),
-  HouseData(100, true, 500000)
-))
-// trainingData: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]
-
-case class Features(squareFeet: Double, hasGarden: Boolean)
-// defined class Features
-
-val assembler = TypedVectorAssembler[Features]
-// assembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@a559710
-
-case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector)
-// defined class HouseDataWithFeatures
-
-val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures]
-// trainingDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]
-
                            -

                            In the above code snippet, .as[HouseDataWithFeatures] is a TypedDataset's type-safe cast -(see TypedDataset: Feature Overview):

                            -
                            case class WrongHouseFeatures(
-  squareFeet: Double,
-  hasGarden: Int, // hasGarden has wrong type
-  price: Double,
-  features: Vector
-)
-
                            -
                            assembler.transform(trainingData).as[WrongHouseFeatures]
-// <console>:39: error: could not find implicit value for parameter as: frameless.ops.As[(Double, Boolean, Double, org.apache.spark.ml.linalg.Vector),WrongHouseFeatures]
-//        assembler.transform(trainingData).as[WrongHouseFeatures]
-//                                            ^
-
                            -

                            Moreover, TypedVectorAssembler[Features] will compile only if Features contains exclusively fields of type Numeric or Boolean:

                            -
                            case class WrongFeatures(squareFeet: Double, hasGarden: Boolean, city: String)
-
                            -
                            TypedVectorAssembler[WrongFeatures]
-// <console>:37: error: Cannot prove that WrongFeatures is a valid input type. Input type must only contain fields of numeric or boolean types.
-//        TypedVectorAssembler[WrongFeatures]
-//                            ^
-
                            -

                            The subsequent call assembler.transform(trainingData) compiles only if trainingData contains all fields (names and types) -of Features:

                            -
                            case class WrongHouseData(squareFeet: Double, price: Double) // hasGarden is missing
-// defined class WrongHouseData
-
-val wrongTrainingData = TypedDataset.create(Seq(WrongHouseData(20, 100000)))
-// wrongTrainingData: frameless.TypedDataset[WrongHouseData] = [squareFeet: double, price: double]
-
                            -
                            assembler.transform(wrongTrainingData)
-// <console>:37: error: Cannot prove that WrongHouseData can be projected to Features. Perhaps not all member names and types of Features are the same in WrongHouseData?
-//        assembler.transform(wrongTrainingData)
-//                           ^
-
                            -

                            Then, we train the model. To train a Random Forest, one needs to feed it with features (what we predict from) and -with a label (what we predict). In our example, price is the label, features are the features:

                            -
                            case class RFInputs(price: Double, features: Vector)
-// defined class RFInputs
-
-val rf = TypedRandomForestRegressor[RFInputs]
-// rf: frameless.ml.regression.TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@37d61f51
-
-val model = rf.fit(trainingDataWithFeatures).run()
-// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.regression.TypedRandomForestRegressor.Outputs,org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@5d5c3
-
                            -

                            TypedRandomForestRegressor[RFInputs] compiles only if RFInputs -contains only one field of type Double (the label) and one field of type Vector (the features):

                            -
                            case class WrongRFInputs(labelOfWrongType: String, features: Vector)
-
                            -
                            TypedRandomForestRegressor[WrongRFInputs]
-// <console>:37: error: Cannot prove that WrongRFInputs is a valid input type. Input type must only contain a field of type Double (the label) and a field of type org.apache.spark.ml.linalg.Vector (the features).
-//        TypedRandomForestRegressor[WrongRFInputs]
-//                                  ^
-
                            -

                            The subsequent rf.fit(trainingDataWithFeatures) call compiles only if trainingDataWithFeatures contains the same fields -(names and types) as RFInputs.

                            -
                            val wrongTrainingDataWithFeatures = TypedDataset.create(Seq(HouseData(20, false, 100000))) // features are missing
-// wrongTrainingDataWithFeatures: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]
-
                            -
                            rf.fit(wrongTrainingDataWithFeatures) 
-// <console>:37: error: Cannot prove that HouseData can be projected to RFInputs. Perhaps not all member names and types of RFInputs are the same in HouseData?
-//        rf.fit(wrongTrainingDataWithFeatures)
-//              ^
-
                            -

                            Prediction

                            -

                            We now want to predict price for testData using the previously trained model. Like the Spark ML API, -testData has a default value for price (0 in our case) that will be ignored at prediction time. We reuse -our assembler to compute the feature vector of testData.

                            -
                            val testData = TypedDataset.create(Seq(HouseData(70, true, 0)))
-// testData: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]
-
-val testDataWithFeatures = assembler.transform(testData).as[HouseDataWithFeatures]
-// testDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]
-
-case class HousePricePrediction(
-  squareFeet: Double,
-  hasGarden: Boolean,
-  price: Double,
-  features: Vector,
-  predictedPrice: Double
-)
-// defined class HousePricePrediction
-
-val predictions = model.transform(testDataWithFeatures).as[HousePricePrediction]
-// predictions: frameless.TypedDataset[HousePricePrediction] = [squareFeet: double, hasGarden: boolean ... 3 more fields]
-
-predictions.select(predictions.col('predictedPrice)).collect.run()
-// res6: Seq[Double] = WrappedArray(296250.0)
-
                            -

                            model.transform(testDataWithFeatures) will only compile if testDataWithFeatures contains a field price of type Double -and a field features of type Vector:

                            -
                            model.transform(testData)
-// <console>:37: error: Cannot prove that HouseData can be projected to RFInputs. Perhaps not all member names and types of RFInputs are the same in HouseData?
-//        model.transform(testData)
-//                       ^
-
                            -

                            Example 2: predict a categorical value using a TypedRandomForestClassifier

                            -

                            In this example, we want to predict in which city a house is located depending on its price and its square footage. We use a -TypedRandomForestClassifier.

                            -

                            Training

                            -

                            As with the Spark ML API, we use a TypedVectorAssembler to compute feature vectors and a TypedStringIndexer -to index city values in order to be able to pass them to a TypedRandomForestClassifier -(which only accepts Double values as label):

                            -
                            import frameless.ml.classification._
-
                            -
                            case class HouseData(squareFeet: Double, city: String, price: Double)
-// defined class HouseData
-
-val trainingData = TypedDataset.create(Seq(
-  HouseData(100, "lyon", 100000),
-  HouseData(200, "lyon", 200000),
-  HouseData(100, "san francisco", 500000),
-  HouseData(150, "san francisco", 900000)
-))
-// trainingData: frameless.TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]
-
-case class Features(price: Double, squareFeet: Double)
-// defined class Features
-
-val vectorAssembler = TypedVectorAssembler[Features]
-// vectorAssembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@eb06753
-
-case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector)
-// defined class HouseDataWithFeatures
-
-val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures]
-// dataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]
-
-case class StringIndexerInput(city: String)
-// defined class StringIndexerInput
-
-val indexer = TypedStringIndexer[StringIndexerInput]
-// indexer: frameless.ml.feature.TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@4c2621e0
-
-indexer.estimator.setHandleInvalid("keep")
-// res8: indexer.estimator.type = strIdx_267bc5cb88b4
-
-val indexerModel = indexer.fit(dataWithFeatures).run()
-// indexerModel: frameless.ml.AppendTransformer[StringIndexerInput,frameless.ml.feature.TypedStringIndexer.Outputs,org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@6145e82d
-
-case class HouseDataWithFeaturesAndIndex(
-  squareFeet: Double,
-  city: String,
-  price: Double,
-  features: Vector,
-  cityIndexed: Double
-)
-// defined class HouseDataWithFeaturesAndIndex
-
-val indexedData = indexerModel.transform(dataWithFeatures).as[HouseDataWithFeaturesAndIndex]
-// indexedData: frameless.TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]
-
                            -

                            Then, we train the model:

                            -
                            case class RFInputs(cityIndexed: Double, features: Vector)
-// defined class RFInputs
-
-val rf = TypedRandomForestClassifier[RFInputs]
-// rf: frameless.ml.classification.TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@33ab9b32
-
-val model = rf.fit(indexedData).run()
-// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.classification.TypedRandomForestClassifier.Outputs,org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@5bd75b8e
-
                            -

                            Prediction

                            -

                            We now want to predict city for testData using the previously trained model. Like the Spark ML API, -testData has a default value for city (empty string in our case) that will be ignored at prediction time. We reuse -our vectorAssembler to compute the feature vector of testData and our indexerModel to index city.

                            -
                            val testData = TypedDataset.create(Seq(HouseData(120, "", 800000)))
-// testData: frameless.TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]
-
-val testDataWithFeatures = vectorAssembler.transform(testData).as[HouseDataWithFeatures]
-// testDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]
-
-val indexedTestData = indexerModel.transform(testDataWithFeatures).as[HouseDataWithFeaturesAndIndex]
-// indexedTestData: frameless.TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]
-
-case class HouseCityPredictionInputs(features: Vector, cityIndexed: Double)
-// defined class HouseCityPredictionInputs
-
-val testInput = indexedTestData.project[HouseCityPredictionInputs]
-// testInput: frameless.TypedDataset[HouseCityPredictionInputs] = [features: vector, cityIndexed: double]
-
-case class HouseCityPredictionIndexed(
-  features: Vector,
-  cityIndexed: Double,
-  rawPrediction: Vector,
-  probability: Vector,
-  predictedCityIndexed: Double
-)
-// defined class HouseCityPredictionIndexed
-
-val indexedPredictions = model.transform(testInput).as[HouseCityPredictionIndexed]
-// indexedPredictions: frameless.TypedDataset[HouseCityPredictionIndexed] = [features: vector, cityIndexed: double ... 3 more fields]
-
                            -

                            Then, we use a TypedIndexToString to get back a String value from predictedCityIndexed. TypedIndexToString takes -as input the label array computed by our previous indexerModel:

                            -
                            case class IndexToStringInput(predictedCityIndexed: Double)
-// defined class IndexToStringInput
-
-val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// <console>:40: warning: method labels in class StringIndexerModel is deprecated (since 3.0.0): `labels` is deprecated and will be removed in 3.1.0. Use `labelsArray` instead.
-//        val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-//                                                                                            ^
-// indexToString: frameless.ml.feature.TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@355dd92d
-
-case class HouseCityPrediction(
-  features: Vector,
-  cityIndexed: Double,
-  rawPrediction: Vector,
-  probability: Vector,
-  predictedCityIndexed: Double,
-  predictedCity: String
-)
-// defined class HouseCityPrediction
-
-val predictions = indexToString.transform(indexedPredictions).as[HouseCityPrediction]
-// predictions: frameless.TypedDataset[HouseCityPrediction] = [features: vector, cityIndexed: double ... 4 more fields]
-
-predictions.select(predictions.col('predictedCity)).collect.run()
-// res9: Seq[String] = WrappedArray(san francisco)
-
                            -

                            List of currently implemented TypedEstimators

                            - -

                            List of currently implemented TypedTransformers

                            - -

                            Using Vector and Matrix with TypedDataset

                            -

                            frameless-ml provides TypedEncoder instances for org.apache.spark.ml.linalg.Vector -and org.apache.spark.ml.linalg.Matrix:

                            -
                            import frameless._
-import frameless.ml._
-import org.apache.spark.ml.linalg._
-
                            -
                            val vector = Vectors.dense(1, 2, 3)
-// vector: org.apache.spark.ml.linalg.Vector = [1.0,2.0,3.0]
-
-val vectorDs = TypedDataset.create(Seq("label" -> vector))
-// vectorDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Vector)] = [_1: string, _2: vector]
-
-val matrix = Matrices.dense(2, 1, Array(1, 2))
-// matrix: org.apache.spark.ml.linalg.Matrix =
-// 1.0
-// 2.0
-
-val matrixDs = TypedDataset.create(Seq("label" -> matrix))
-// matrixDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Matrix)] = [_1: string, _2: matrix]
-
                            -

                            Under the hood, Vector and Matrix are encoded using org.apache.spark.ml.linalg.VectorUDT -and org.apache.spark.ml.linalg.MatrixUDT. This is possible thanks to the implicit derivation -from org.apache.spark.sql.types.UserDefinedType[A] to TypedEncoder[A] defined in TypedEncoder companion object.

                            - - -
                            - -
                            -
                            -
                            - -

                            results matching ""

                            -
                              - -
                              -
                              - -

                              No results matching ""

                              - -
                              -
                              -
                              - -
                              -
                              - -
                              - - - - - - - - - - - - - - -
                              - - -
                              - - - - - - + + + + + + + + + + + + + + +
                              + + + +
                              + +

                              Typed Spark ML

                              +

                              The frameless-ml module provides a strongly typed Spark ML API leveraging TypedDatasets. It introduces TypedTransformers + and TypedEstimators, the type-safe equivalents of Spark ML's Transformer and Estimator.

                              +

                              A TypedEstimator fits models to data, i.e trains a ML model based on an input TypedDataset. + A TypedTransformer transforms one TypedDataset into another, usually by appending column(s) to it.

                              +

                              By calling the fit method of a TypedEstimator, the TypedEstimator will train a ML model using the TypedDataset + passed as input (representing the training data) and will return a TypedTransformer that represents the trained model. + This TypedTransformercan then be used to make predictions on an input TypedDataset (representing the test data) + using the transform method that will return a new TypedDataset with appended prediction column(s).

                              +

                              Both TypedEstimator and TypedTransformer check at compile-time the correctness of their inputs field names and types, + contrary to Spark ML API which only deals with DataFrames (the data structure with the lowest level of type-safety in Spark).

                              +

                              frameless-ml adds type-safety to Spark ML API but stays very close to it in terms of abstractions and API calls, so + please check Spark ML documentation for more details + on Transformers and Estimators.

                              - +

                              Example 1: predict a continuous value using a TypedRandomForestRegressor

                              +

                              In this example, we want to predict the sale price of a house depending on its square footage and the fact that the house + has a garden or not. We will use a TypedRandomForestRegressor.

                              - +

                              Training

                              +

                              As with the Spark ML API, we use a TypedVectorAssembler (the type-safe equivalent of VectorAssembler) + to compute feature vectors:

                              + 
                              import frameless._
+import frameless.syntax._
+import frameless.ml._
+import frameless.ml.feature._
+import frameless.ml.regression._
+import org.apache.spark.ml.linalg.Vector
                              + 
                              case class HouseData(squareFeet: Double, hasGarden: Boolean, price: Double)
+
+val trainingData = TypedDataset.create(Seq(
+  HouseData(20, false, 100000),
+  HouseData(50, false, 200000),
+  HouseData(50, true, 250000),
+  HouseData(100, true, 500000)
+))
+// trainingData: TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]
+
+case class Features(squareFeet: Double, hasGarden: Boolean)
+val assembler = TypedVectorAssembler[Features]
+// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@604ca2fd
+
+case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector)
+val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures]
+// trainingDataWithFeatures: TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]
                              +

                              In the above code snippet, .as[HouseDataWithFeatures] is a TypedDataset's type-safe cast + (see TypedDataset: Feature Overview):

                              + 
                              case class WrongHouseFeatures(
+  squareFeet: Double,
+  hasGarden: Int, // hasGarden has wrong type
+  price: Double,
+  features: Vector
+)
                              + 
                              assembler.transform(trainingData).as[WrongHouseFeatures]
+// error: could not find implicit value for parameter as: frameless.ops.As[(Double, Boolean, Double, org.apache.spark.ml.linalg.Vector),repl.MdocSession.App0.WrongHouseFeatures]
+// assembler.transform(trainingData).as[WrongHouseFeatures]
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                              +

                              Moreover, TypedVectorAssembler[Features] will compile only if Features contains exclusively fields of type Numeric or Boolean:

                              + 
                              case class WrongFeatures(squareFeet: Double, hasGarden: Boolean, city: String)
                              + 
                              TypedVectorAssembler[WrongFeatures]
+// error: Cannot prove that repl.MdocSession.App0.WrongFeatures is a valid input type. Input type must only contain fields of numeric or boolean types.
+// TypedVectorAssembler[WrongFeatures]
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                              +

                              The subsequent call assembler.transform(trainingData) compiles only if trainingData contains all fields (names and types) + of Features:

                              + 
                              case class WrongHouseData(squareFeet: Double, price: Double) // hasGarden is missing // hasGarden is missing
+val wrongTrainingData = TypedDataset.create(Seq(WrongHouseData(20, 100000)))
+// wrongTrainingData: TypedDataset[WrongHouseData] = [squareFeet: double, price: double]
                              + 
                              assembler.transform(wrongTrainingData)
+// error: Cannot prove that repl.MdocSession.App0.WrongHouseData can be projected to repl.MdocSession.App0.Features. Perhaps not all member names and types of repl.MdocSession.App0.Features are the same in repl.MdocSession.App0.WrongHouseData?
+// assembler.transform(wrongTrainingData)
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                              +

                              Then, we train the model. To train a Random Forest, one needs to feed it with features (what we predict from) and + with a label (what we predict). In our example, price is the label, features are the features:

                              + 
                              case class RFInputs(price: Double, features: Vector)
+val rf = TypedRandomForestRegressor[RFInputs]
+// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@e882e0b
+
+val model = rf.fit(trainingDataWithFeatures).run()
+// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@38d8d51b
                              +

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs + contains only one field of type Double (the label) and one field of type Vector (the features):

                              + 
                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              + 
                              TypedRandomForestRegressor[WrongRFInputs]
+// error: Cannot prove that repl.MdocSession.App0.WrongRFInputs is a valid input type. Input type must only contain a field of type Double (the label) and a field of type org.apache.spark.ml.linalg.Vector (the features).
+// TypedRandomForestRegressor[WrongRFInputs]
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                              +

                              The subsequent rf.fit(trainingDataWithFeatures) call compiles only if trainingDataWithFeatures contains the same fields + (names and types) as RFInputs.

                              + 
                              val wrongTrainingDataWithFeatures = TypedDataset.create(Seq(HouseData(20, false, 100000))) // features are missing
+// wrongTrainingDataWithFeatures: TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]
                              + 
                              rf.fit(wrongTrainingDataWithFeatures) 
+// error: Cannot prove that repl.MdocSession.App0.HouseData can be projected to repl.MdocSession.App0.RFInputs. Perhaps not all member names and types of repl.MdocSession.App0.RFInputs are the same in repl.MdocSession.App0.HouseData?
+// rf.fit(wrongTrainingDataWithFeatures) 
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                              - +

                              Prediction

                              +

                              We now want to predict price for testData using the previously trained model. Like the Spark ML API, + testData has a default value for price (0 in our case) that will be ignored at prediction time. We reuse + our assembler to compute the feature vector of testData.

                              + 
                              val testData = TypedDataset.create(Seq(HouseData(70, true, 0)))
+// testData: TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]
+val testDataWithFeatures = assembler.transform(testData).as[HouseDataWithFeatures]
+// testDataWithFeatures: TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]
+
+case class HousePricePrediction(
+  squareFeet: Double,
+  hasGarden: Boolean,
+  price: Double,
+  features: Vector,
+  predictedPrice: Double
+)
+val predictions = model.transform(testDataWithFeatures).as[HousePricePrediction]
+// predictions: TypedDataset[HousePricePrediction] = [squareFeet: double, hasGarden: boolean ... 3 more fields]
+
+predictions.select(predictions.col('predictedPrice)).collect.run()
+// res7: Seq[Double] = WrappedArray(253083.3333333333)
                              +

                              model.transform(testDataWithFeatures) will only compile if testDataWithFeatures contains a field price of type Double + and a field features of type Vector:

                              + 
                              model.transform(testData)
+// error: Cannot prove that repl.MdocSession.App0.HouseData can be projected to repl.MdocSession.App0.RFInputs. Perhaps not all member names and types of repl.MdocSession.App0.RFInputs are the same in repl.MdocSession.App0.HouseData?
+// val model = rf.fit(indexedData).run()
+//     ^^^^^^^^^^^^^^^^^^^^
                              - +

                              Example 2: predict a categorical value using a TypedRandomForestClassifier

                              +

                              In this example, we want to predict in which city a house is located depending on its price and its square footage. We use a + TypedRandomForestClassifier.

                              - +

                              Training

                              +

                              As with the Spark ML API, we use a TypedVectorAssembler to compute feature vectors and a TypedStringIndexer + to index city values in order to be able to pass them to a TypedRandomForestClassifier + (which only accepts Double values as label):

                              + 
                              import frameless.ml.classification._
                              + 
                              case class HouseData(squareFeet: Double, city: String, price: Double)
+
+val trainingData = TypedDataset.create(Seq(
+  HouseData(100, "lyon", 100000),
+  HouseData(200, "lyon", 200000),
+  HouseData(100, "san francisco", 500000),
+  HouseData(150, "san francisco", 900000)
+))
+// trainingData: TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]
+
+case class Features(price: Double, squareFeet: Double)
+val vectorAssembler = TypedVectorAssembler[Features]
+// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@40d7ae21
+
+case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector)
+val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures]
+// dataWithFeatures: TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]
+
+case class StringIndexerInput(city: String)
+val indexer = TypedStringIndexer[StringIndexerInput]
+// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@91f3043
+indexer.estimator.setHandleInvalid("keep")
+// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_939a8eadf96b
+val indexerModel = indexer.fit(dataWithFeatures).run()
+// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@329efd3e
+
+case class HouseDataWithFeaturesAndIndex(
+  squareFeet: Double,
+  city: String,
+  price: Double,
+  features: Vector,
+  cityIndexed: Double
+)
+val indexedData = indexerModel.transform(dataWithFeatures).as[HouseDataWithFeaturesAndIndex]
+// indexedData: TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]
                              +

                              Then, we train the model:

                              + 
                              case class RFInputs(cityIndexed: Double, features: Vector)
+val rf = TypedRandomForestClassifier[RFInputs]
+// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@26ebb6de
+
+val model = rf.fit(indexedData).run()
+// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@5bb0a284
                              - +

                              Prediction

                              +

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, + testData has a default value for city (empty string in our case) that will be ignored at prediction time. We reuse + our vectorAssembler to compute the feature vector of testData and our indexerModel to index city.

                              + 
                              val testData = TypedDataset.create(Seq(HouseData(120, "", 800000)))
+// testData: TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]
+
+val testDataWithFeatures = vectorAssembler.transform(testData).as[HouseDataWithFeatures]
+// testDataWithFeatures: TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]
+val indexedTestData = indexerModel.transform(testDataWithFeatures).as[HouseDataWithFeaturesAndIndex]
+// indexedTestData: TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]
+
+case class HouseCityPredictionInputs(features: Vector, cityIndexed: Double)
+val testInput = indexedTestData.project[HouseCityPredictionInputs]
+// testInput: TypedDataset[HouseCityPredictionInputs] = [features: vector, cityIndexed: double]
+
+case class HouseCityPredictionIndexed(
+  features: Vector,
+  cityIndexed: Double,
+  rawPrediction: Vector,
+  probability: Vector,
+  predictedCityIndexed: Double
+)
+val indexedPredictions = model.transform(testInput).as[HouseCityPredictionIndexed]
+// indexedPredictions: TypedDataset[HouseCityPredictionIndexed] = [features: vector, cityIndexed: double ... 3 more fields]
                              +

                              Then, we use a TypedIndexToString to get back a String value from predictedCityIndexed. TypedIndexToString takes + as input the label array computed by our previous indexerModel:

                              + 
                              case class IndexToStringInput(predictedCityIndexed: Double)
+val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@2b5d1c99
+
+case class HouseCityPrediction(
+  features: Vector,
+  cityIndexed: Double,
+  rawPrediction: Vector,
+  probability: Vector,
+  predictedCityIndexed: Double,
+  predictedCity: String
+)
+val predictions = indexToString.transform(indexedPredictions).as[HouseCityPrediction]
+// predictions: TypedDataset[HouseCityPrediction] = [features: vector, cityIndexed: double ... 4 more fields]
+
+predictions.select(predictions.col('predictedCity)).collect.run()
+// res13: Seq[String] = WrappedArray("san francisco")
                              - +

                              List of currently implemented TypedEstimators

                              + - +

                              List of currently implemented TypedTransformers

                              + - +

                              Using Vector and Matrix with TypedDataset

                              +

                              frameless-ml provides TypedEncoder instances for org.apache.spark.ml.linalg.Vector + and org.apache.spark.ml.linalg.Matrix:

                              + 
                              import frameless._
+import frameless.ml._
+import org.apache.spark.ml.linalg._
                              + 
                              val vector = Vectors.dense(1, 2, 3)
+// vector: Vector = [1.0,2.0,3.0]
+val vectorDs = TypedDataset.create(Seq("label" -> vector))
+// vectorDs: TypedDataset[(String, Vector)] = [_1: string, _2: vector]
+
+val matrix = Matrices.dense(2, 1, Array(1, 2))
+// matrix: Matrix = 1.0  
+// 2.0  
+val matrixDs = TypedDataset.create(Seq("label" -> matrix))
+// matrixDs: TypedDataset[(String, Matrix)] = [_1: string, _2: matrix]
                              +

                              Under the hood, Vector and Matrix are encoded using org.apache.spark.ml.linalg.VectorUDT + and org.apache.spark.ml.linalg.MatrixUDT. This is possible thanks to the implicit derivation + from org.apache.spark.sql.types.UserDefinedType[A] to TypedEncoder[A] defined in TypedEncoder companion object.

                              + +
                              - - +
                              + + \ No newline at end of file diff --git a/WorkingWithCsvParquetJson.html b/WorkingWithCsvParquetJson.html new file mode 100644 index 000000000..020e33dab --- /dev/null +++ b/WorkingWithCsvParquetJson.html @@ -0,0 +1,242 @@ + + + + + + + + Working with CSV and Parquet data + + + + + + + + + + + + + + + + + + + + +
                              + +
                              + + + + +
                              + + + + + + + + + +
                              + + + +
                              + + + +
                              + +

                              Working with CSV and Parquet data

                              +

                              You need these imports for most Frameless projects.

                              + 
                              import frameless._
+import frameless.syntax._
+import frameless.functions.aggregate._
                              + +

                              Working with CSV

                              +

                              We first load some CSV data and print the schema.

                              + 
                              val df = spark.read.format("csv").load(testDataPath)
+// df: org.apache.spark.sql.package.DataFrame = [_c0: string, _c1: string ... 3 more fields]
+df.show(2)
+// +---+---+---+---+-----------+
+// |_c0|_c1|_c2|_c3|        _c4|
+// +---+---+---+---+-----------+
+// |5.1|3.5|1.4|0.2|Iris-setosa|
+// |4.9|3.0|1.4|0.2|Iris-setosa|
+// +---+---+---+---+-----------+
+// only showing top 2 rows
+// 
+df.printSchema
+// root
+//  |-- _c0: string (nullable = true)
+//  |-- _c1: string (nullable = true)
+//  |-- _c2: string (nullable = true)
+//  |-- _c3: string (nullable = true)
+//  |-- _c4: string (nullable = true)
+//
                              +

                              The easiest way to read from CSV into a TypedDataset is to create a case class that follows + the exact number, type, and order for the fields as they appear in the CSV file. This is shown in + the example bellow with the use of the Iris case class.

                              + 
                              final case class Iris(sLength: Double, sWidth: Double, pLength: Double, pWidth: Double, kind: String)
+val testDataDf = spark.read.format("csv").schema(TypedExpressionEncoder[Iris].schema).load(testDataPath)
+// testDataDf: org.apache.spark.sql.package.DataFrame = [sLength: double, sWidth: double ... 3 more fields]
+val data: TypedDataset[Iris] = TypedDataset.createUnsafe[Iris](testDataDf)
+// data: TypedDataset[Iris] = [sLength: double, sWidth: double ... 3 more fields]
+data.show(2).run()
+// +-------+------+-------+------+-----------+
+// |sLength|sWidth|pLength|pWidth|       kind|
+// +-------+------+-------+------+-----------+
+// |    5.1|   3.5|    1.4|   0.2|Iris-setosa|
+// |    4.9|   3.0|    1.4|   0.2|Iris-setosa|
+// +-------+------+-------+------+-----------+
+// only showing top 2 rows
+//
                              +

                              If we do not explicitly define the schema of the CSV file then the types will not match leading to runtime errors.

                              + 
                              val testDataNoSchema = spark.read.format("csv").load(testDataPath)
+// testDataNoSchema: org.apache.spark.sql.package.DataFrame = [_c0: string, _c1: string ... 3 more fields]
+val data: TypedDataset[Iris] = TypedDataset.createUnsafe[Iris](testDataNoSchema)
+// data: TypedDataset[Iris] = [sLength: string, sWidth: string ... 3 more fields]
                              + 
                              data.collect().run()
+// java.lang.RuntimeException: Error while decoding: scala.ScalaReflectionException: <none> is not a term
+// newInstance(class repl.MdocSession$App0$Iris)
+// 	at org.apache.spark.sql.errors.QueryExecutionErrors$.expressionDecodingError(QueryExecutionErrors.scala:1047)
+// 	at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$Deserializer.apply(ExpressionEncoder.scala:184)
+// 	at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$Deserializer.apply(ExpressionEncoder.scala:172)
+// 	at scala.collection.TraversableLike.$anonfun$map$1(TraversableLike.scala:286)
+// 	at scala.collection.IndexedSeqOptimized.foreach(IndexedSeqOptimized.scala:36)
+// 	at scala.collection.IndexedSeqOptimized.foreach$(IndexedSeqOptimized.scala:33)
+// 	at scala.collection.mutable.ArrayOps$ofRef.foreach(ArrayOps.scala:198)
+// 	at scala.collection.TraversableLike.map(TraversableLike.scala:286)
+// 	at scala.collection.TraversableLike.map$(TraversableLike.scala:279)
+// 	at scala.collection.mutable.ArrayOps$ofRef.map(ArrayOps.scala:198)
+// 	at org.apache.spark.sql.Dataset.collectFromPlan(Dataset.scala:3715)
+// 	at org.apache.spark.sql.Dataset.$anonfun$collect$1(Dataset.scala:2971)
+// 	at org.apache.spark.sql.Dataset.$anonfun$withAction$1(Dataset.scala:3706)
+// 	at org.apache.spark.sql.execution.SQLExecution$.$anonfun$withNewExecutionId$5(SQLExecution.scala:103)
+// 	at org.apache.spark.sql.execution.SQLExecution$.withSQLConfPropagated(SQLExecution.scala:163)
+// 	at org.apache.spark.sql.execution.SQLExecution$.$anonfun$withNewExecutionId$1(SQLExecution.scala:90)
+// 	at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:775)
+// 	at org.apache.spark.sql.execution.SQLExecution$.withNewExecutionId(SQLExecution.scala:64)
+// 	at org.apache.spark.sql.Dataset.withAction(Dataset.scala:3704)
+// 	at org.apache.spark.sql.Dataset.collect(Dataset.scala:2971)
+// 	at frameless.TypedDataset.$anonfun$collect$1(TypedDataset.scala:317)
+// 	at frameless.Job$$anon$4.run(Job.scala:38)
+// 	at repl.MdocSession$App0$$anonfun$25.apply(WorkingWithCsvParquetJson.md:85)
+// 	at repl.MdocSession$App0$$anonfun$25.apply(WorkingWithCsvParquetJson.md:85)
+// Caused by: scala.ScalaReflectionException: <none> is not a term
+// 	at scala.reflect.api.Symbols$SymbolApi.asTerm(Symbols.scala:211)
+// 	at scala.reflect.api.Symbols$SymbolApi.asTerm$(Symbols.scala:211)
+// 	at scala.reflect.internal.Symbols$SymbolContextApiImpl.asTerm(Symbols.scala:100)
+// 	at org.apache.spark.sql.catalyst.ScalaReflection$.findConstructor(ScalaReflection.scala:819)
+// 	at org.apache.spark.sql.catalyst.expressions.objects.NewInstance.$anonfun$constructor$1(objects.scala:525)
+// 	at org.apache.spark.sql.catalyst.expressions.objects.NewInstance.$anonfun$constructor$5(objects.scala:536)
+// 	at scala.Option.getOrElse(Option.scala:189)
+// 	at org.apache.spark.sql.catalyst.expressions.objects.NewInstance.constructor$lzycompute(objects.scala:535)
+// 	at org.apache.spark.sql.catalyst.expressions.objects.NewInstance.constructor(objects.scala:522)
+// 	at org.apache.spark.sql.catalyst.expressions.objects.NewInstance.eval(objects.scala:545)
+// 	at org.apache.spark.sql.catalyst.expressions.InterpretedSafeProjection.apply(InterpretedSafeProjection.scala:117)
+// 	at org.apache.spark.sql.catalyst.expressions.InterpretedSafeProjection.apply(InterpretedSafeProjection.scala:32)
+// 	at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$Deserializer.apply(ExpressionEncoder.scala:181)
+// 	... 22 more
                              + +

                              Dealing with CSV files with multiple columns

                              +

                              When the dataset has many columns, it is impractical to define a case class that contains many columns we don't need. + In such case, we can project the columns we do need, cast them to the proper type, and then call createUnsafe using a case class + that contains a much smaller subset of the columns.

                              + 
                              import org.apache.spark.sql.types.DoubleType
+final case class IrisLight(kind: String, sLength: Double)
+
+val testDataDf = spark.read.format("csv").load(testDataPath)
+// testDataDf: org.apache.spark.sql.package.DataFrame = [_c0: string, _c1: string ... 3 more fields]
+val projectedDf = testDataDf.select(testDataDf("_c4").as("kind"), testDataDf("_c1").cast(DoubleType).as("sLength"))
+// projectedDf: org.apache.spark.sql.package.DataFrame = [kind: string, sLength: double]
+val data = TypedDataset.createUnsafe[IrisLight](projectedDf)
+// data: TypedDataset[IrisLight] = [kind: string, sLength: double]
+data.take(2).run()
+// res5: Seq[IrisLight] = WrappedArray(
+//   IrisLight("Iris-setosa", 3.5),
+//   IrisLight("Iris-setosa", 3.0)
+// )
                              + +

                              Working with Parquet

                              +

                              Spark is much better at reading the schema from parquet files.

                              + 
                              val testDataParquet = spark.read.format("parquet").load(testDataPathParquet)
+// testDataParquet: org.apache.spark.sql.package.DataFrame = [sLength: double, sWidth: double ... 3 more fields]
+testDataParquet.printSchema
+// root
+//  |-- sLength: double (nullable = true)
+//  |-- sWidth: double (nullable = true)
+//  |-- pLength: double (nullable = true)
+//  |-- pWidth: double (nullable = true)
+//  |-- kind: string (nullable = true)
+//
                              +

                              So as long as we use a type (case class) that reflects the same number, type, and order of the fields + from the data everything works as expected.

                              + 
                              val data: TypedDataset[Iris] = TypedDataset.createUnsafe[Iris](testDataParquet)
+// data: TypedDataset[Iris] = [sLength: double, sWidth: double ... 3 more fields]
+data.take(2).run()
+// res10: Seq[Iris] = WrappedArray(
+//   Iris(5.1, 3.5, 1.4, 0.2, "Iris-setosa"),
+//   Iris(4.9, 3.0, 1.4, 0.2, "Iris-setosa")
+// )
                              + +

                              Dealing with Parquet files with multiple columns

                              +

                              The main difference compared to CSV is that with Parquet Spark is better at inferring the types. This makes it simpler + to project the columns we need without having the cast the to the proper type.

                              + 
                              final case class IrisLight(kind: String, sLength: Double)
+
+val projectedDf = testDataParquet.select("kind", "sLength")
+// projectedDf: org.apache.spark.sql.package.DataFrame = [kind: string, sLength: double]
+val data = TypedDataset.createUnsafe[IrisLight](projectedDf)
+// data: TypedDataset[IrisLight] = [kind: string, sLength: double]
+data.take(2).run()
+// res11: Seq[IrisLight] = WrappedArray(
+//   IrisLight("Iris-setosa", 5.1),
+//   IrisLight("Iris-setosa", 4.9)
+// )
                              + +
                              + +
                              + + + \ No newline at end of file diff --git a/build.sbt b/build.sbt deleted file mode 100644 index 462f3f396..000000000 --- a/build.sbt +++ /dev/null @@ -1,273 +0,0 @@ -val sparkVersion = "3.1.0" -val catsCoreVersion = "2.3.1" -val catsEffectVersion = "2.3.1" -val catsMtlVersion = "0.7.1" -val scalatest = "3.2.3" -val scalatestplus = "3.1.0.0-RC2" -val shapeless = "2.3.3" -val scalacheck = "1.15.2" -val irrecVersion = "0.4.0" - -val Scala212 = "2.12.12" - -ThisBuild / crossScalaVersions := Seq(Scala212) -ThisBuild / scalaVersion := (ThisBuild / crossScalaVersions).value.last - -ThisBuild / githubWorkflowPublishTargetBranches := Seq() - -ThisBuild / githubWorkflowArtifactUpload := false - -ThisBuild / githubWorkflowBuild := Seq( - WorkflowStep.Use("actions", - "setup-python", - "v2", - name = Some("Setup Python"), - params = Map("python-version" -> "3.x") - ), - WorkflowStep.Run(List("pip install codecov"), - name = Some("Setup codecov") - ), - WorkflowStep.Sbt(List("-Dfile.encoding=UTF8", "-J-XX:ReservedCodeCacheSize=256M", "coverage", "test", "coverageReport"), - name = Some("Test & Compute Coverage") - ), - WorkflowStep.Run(List("codecov -F ${{ matrix.scala }}"), - name = Some("Upload Codecov Results") - ) -) - -ThisBuild / githubWorkflowAddedJobs ++= Seq( - WorkflowJob( - "docs", - "Documentation", - githubWorkflowJobSetup.value.toList ::: List( - WorkflowStep.Sbt(List("-Dfile.encoding=UTF8", "-J-XX:ReservedCodeCacheSize=256M", "doc", "tut"), - name = Some("Documentation") - ) - ), - scalas = List(Scala212) - ) -) - -lazy val root = Project("frameless", file("." + "frameless")).in(file(".")) - .aggregate(core, cats, dataset, ml, docs) - .settings(framelessSettings: _*) - .settings(noPublishSettings: _*) - -lazy val core = project - .settings(name := "frameless-core") - .settings(framelessSettings: _*) - .settings(publishSettings: _*) - - -lazy val cats = project - .settings(name := "frameless-cats") - .settings(framelessSettings: _*) - .settings(publishSettings: _*) - .settings( - addCompilerPlugin("org.typelevel" % "kind-projector" % "0.11.3" cross CrossVersion.full), - scalacOptions += "-Ypartial-unification" - ) - .settings(libraryDependencies ++= Seq( - "org.typelevel" %% "cats-core" % catsCoreVersion, - "org.typelevel" %% "cats-effect" % catsEffectVersion, - "org.typelevel" %% "cats-mtl-core" % catsMtlVersion, - "org.typelevel" %% "alleycats-core" % catsCoreVersion, - "org.apache.spark" %% "spark-core" % sparkVersion % "provided", - "org.apache.spark" %% "spark-sql" % sparkVersion % "provided")) - .dependsOn(dataset % "test->test;compile->compile") - -lazy val dataset = project - .settings(name := "frameless-dataset") - .settings(framelessSettings: _*) - .settings(framelessTypedDatasetREPL: _*) - .settings(publishSettings: _*) - .settings(libraryDependencies ++= Seq( - "org.apache.spark" %% "spark-core" % sparkVersion % "provided", - "org.apache.spark" %% "spark-sql" % sparkVersion % "provided", - "net.ceedubs" %% "irrec-regex-gen" % irrecVersion % Test - )) - .dependsOn(core % "test->test;compile->compile") - -lazy val ml = project - .settings(name := "frameless-ml") - .settings(framelessSettings: _*) - .settings(framelessTypedDatasetREPL: _*) - .settings(publishSettings: _*) - .settings(libraryDependencies ++= Seq( - "org.apache.spark" %% "spark-core" % sparkVersion % "provided", - "org.apache.spark" %% "spark-sql" % sparkVersion % "provided", - "org.apache.spark" %% "spark-mllib" % sparkVersion % "provided" - )) - .dependsOn( - core % "test->test;compile->compile", - dataset % "test->test;compile->compile" - ) - -lazy val docs = project - .settings(framelessSettings: _*) - .settings(noPublishSettings: _*) - .settings(scalacOptions --= Seq("-Xfatal-warnings", "-Ywarn-unused-import")) - .enablePlugins(TutPlugin) - .settings(crossTarget := file(".") / "docs" / "target") - .settings(libraryDependencies ++= Seq( - "org.apache.spark" %% "spark-core" % sparkVersion, - "org.apache.spark" %% "spark-sql" % sparkVersion, - "org.apache.spark" %% "spark-mllib" % sparkVersion - )) - .settings( - addCompilerPlugin("org.typelevel" % "kind-projector" % "0.11.3" cross CrossVersion.full), - scalacOptions ++= Seq( - "-Ypartial-unification", - "-Ydelambdafy:inline" - ) - ) - .dependsOn(dataset, cats, ml) - -lazy val framelessSettings = Seq( - organization := "org.typelevel", - scalacOptions ++= commonScalacOptions(scalaVersion.value), - licenses += ("Apache-2.0", url("http://opensource.org/licenses/Apache-2.0")), - testOptions in Test += Tests.Argument(TestFrameworks.ScalaTest, "-oDF"), - libraryDependencies ++= Seq( - "com.chuusai" %% "shapeless" % shapeless, - "org.scalatest" %% "scalatest" % scalatest % "test", - "org.scalatestplus" %% "scalatestplus-scalacheck" % scalatestplus % "test", - "org.scalacheck" %% "scalacheck" % scalacheck % "test"), - javaOptions in Test ++= Seq("-Xmx1G", "-ea"), - fork in Test := true, - parallelExecution in Test := false -) ++ consoleSettings - -def commonScalacOptions(scalaVersion: String): Seq[String] = { - - val versionSpecific = CrossVersion.partialVersion(scalaVersion) match { - case Some((2, 11)) => - Seq("-Xlint:-missing-interpolator,_", "-Yinline-warnings") - case Some((2, n)) if n >= 12 => - Seq("-Xlint:-missing-interpolator,-unused,_") - } - - Seq( - "-target:jvm-1.8", - "-deprecation", - "-encoding", "UTF-8", - "-feature", - "-unchecked", - "-Xfatal-warnings", - "-Yno-adapted-args", - "-Ywarn-dead-code", - "-Ywarn-numeric-widen", - "-Ywarn-unused-import", - "-Ywarn-value-discard", - "-language:existentials", - "-language:implicitConversions", - "-language:higherKinds", - "-Xfuture") ++ versionSpecific -} - -lazy val consoleSettings = Seq( - scalacOptions in (Compile, console) ~= {_.filterNot("-Ywarn-unused-import" == _)}, - scalacOptions in (Test, console) := (scalacOptions in (Compile, console)).value -) - -lazy val framelessTypedDatasetREPL = Seq( - initialize ~= { _ => // Color REPL - val ansi = System.getProperty("sbt.log.noformat", "false") != "true" - if (ansi) System.setProperty("scala.color", "true") - }, - initialCommands in console := - """ - |import org.apache.spark.{SparkConf, SparkContext} - |import org.apache.spark.sql.SparkSession - |import frameless.functions.aggregate._ - |import frameless.syntax._ - | - |val conf = new SparkConf().setMaster("local[*]").setAppName("frameless repl").set("spark.ui.enabled", "false") - |implicit val spark = SparkSession.builder().config(conf).appName("REPL").getOrCreate() - | - |import spark.implicits._ - | - |spark.sparkContext.setLogLevel("WARN") - | - |import frameless.TypedDataset - """.stripMargin, - cleanupCommands in console := - """ - |spark.stop() - """.stripMargin -) - -lazy val publishSettings = Seq( - publishMavenStyle := true, - publishTo := { - val nexus = "https://oss.sonatype.org/" - if (isSnapshot.value) - Some("snapshots" at nexus + "content/repositories/snapshots") - else - Some("releases" at nexus + "service/local/staging/deploy/maven2") - }, - publishArtifact in Test := false, - pomIncludeRepository := Function.const(false), - pomExtra in Global := { - https://github.com/typelevel/frameless - - git@github.com:typelevel/frameless.git - scm:git:git@github.com:typelevel/frameless.git - - - - OlivierBlanvillain - Olivier Blanvillain - https://github.com/OlivierBlanvillain/ - - - adelbertc - Adelbert Chang - https://github.com/adelbertc/ - - - imarios - Marios Iliofotou - https://github.com/imarios/ - - - kanterov - Gleb Kanterov - https://github.com/kanterov/ - - - non - Erik Osheim - https://github.com/non/ - - - jeremyrsmith - Jeremy Smith - https://github.com/jeremyrsmith/ - - - } -) - -lazy val noPublishSettings = Seq( - publish := (()), - publishLocal := (()), - publishArtifact := false -) - -lazy val credentialSettings = Seq( - // For Travis CI - see http://www.cakesolutions.net/teamblogs/publishing-artefacts-to-oss-sonatype-nexus-using-sbt-and-travis-ci - credentials ++= (for { - username <- Option(System.getenv().get("SONATYPE_USERNAME")) - password <- Option(System.getenv().get("SONATYPE_PASSWORD")) - } yield Credentials("Sonatype Nexus Repository Manager", "oss.sonatype.org", username, password)).toSeq -) - - -lazy val copyReadme = taskKey[Unit]("copy for website generation") -lazy val copyReadmeImpl = Def.task { - val from = baseDirectory.value / "README.md" - val to = baseDirectory.value / "docs" / "src" / "main" / "tut" / "README.md" - sbt.IO.copy(List((from, to)), overwrite = true, preserveLastModified = true, preserveExecutable = true) -} -copyReadme := copyReadmeImpl.value diff --git a/cats/src/main/scala/frameless/cats/FramelessSyntax.scala b/cats/src/main/scala/frameless/cats/FramelessSyntax.scala deleted file mode 100644 index 5e616bba3..000000000 --- a/cats/src/main/scala/frameless/cats/FramelessSyntax.scala +++ /dev/null @@ -1,24 +0,0 @@ -package frameless -package cats - -import _root_.cats.effect.Sync -import _root_.cats.implicits._ -import _root_.cats.mtl.ApplicativeAsk -import org.apache.spark.sql.SparkSession - -trait FramelessSyntax extends frameless.FramelessSyntax { - implicit class SparkJobOps[F[_], A](fa: F[A])(implicit S: Sync[F], A: ApplicativeAsk[F, SparkSession]) { - import S._, A._ - - def withLocalProperty(key: String, value: String): F[A] = - for { - session <- ask - _ <- delay(session.sparkContext.setLocalProperty(key, value)) - a <- fa - } yield a - - def withGroupId(groupId: String): F[A] = withLocalProperty("spark.jobGroup.id", groupId) - - def withDescription(description: String) = withLocalProperty("spark.job.description", description) - } -} diff --git a/cats/src/main/scala/frameless/cats/SparkDelayInstances.scala b/cats/src/main/scala/frameless/cats/SparkDelayInstances.scala deleted file mode 100644 index 524c44117..000000000 --- a/cats/src/main/scala/frameless/cats/SparkDelayInstances.scala +++ /dev/null @@ -1,11 +0,0 @@ -package frameless -package cats - -import _root_.cats.effect.Sync -import org.apache.spark.sql.SparkSession - -trait SparkDelayInstances { - implicit def framelessCatsSparkDelayForSync[F[_]](implicit S: Sync[F]): SparkDelay[F] = new SparkDelay[F] { - def delay[A](a: => A)(implicit spark: SparkSession): F[A] = S.delay(a) - } -} diff --git a/cats/src/main/scala/frameless/cats/SparkTask.scala b/cats/src/main/scala/frameless/cats/SparkTask.scala deleted file mode 100644 index 3a6e6330b..000000000 --- a/cats/src/main/scala/frameless/cats/SparkTask.scala +++ /dev/null @@ -1,14 +0,0 @@ -package frameless -package cats - -import _root_.cats.Id -import _root_.cats.data.Kleisli -import org.apache.spark.SparkContext - -object SparkTask { - def apply[A](f: SparkContext => A): SparkTask[A] = - Kleisli[Id, SparkContext, A](f) - - def pure[A](a: => A): SparkTask[A] = - Kleisli[Id, SparkContext, A](_ => a) -} diff --git a/cats/src/main/scala/frameless/cats/implicits.scala b/cats/src/main/scala/frameless/cats/implicits.scala deleted file mode 100644 index f5de35769..000000000 --- a/cats/src/main/scala/frameless/cats/implicits.scala +++ /dev/null @@ -1,74 +0,0 @@ -package frameless -package cats - -import _root_.cats._ -import _root_.cats.kernel.{CommutativeMonoid, CommutativeSemigroup} -import _root_.cats.implicits._ -import alleycats.Empty - -import scala.reflect.ClassTag -import org.apache.spark.rdd.RDD - -object implicits extends FramelessSyntax with SparkDelayInstances { - implicit class rddOps[A: ClassTag](lhs: RDD[A]) { - def csum(implicit m: CommutativeMonoid[A]): A = - lhs.fold(m.empty)(_ |+| _) - def csumOption(implicit m: CommutativeSemigroup[A]): Option[A] = - lhs.aggregate[Option[A]](None)( - (acc, a) => Some(acc.fold(a)(_ |+| a)), - (l, r) => l.fold(r)(x => r.map(_ |+| x) orElse Some(x)) - ) - - def cmin(implicit o: Order[A], e: Empty[A]): A = { - if (lhs.isEmpty) e.empty - else lhs.reduce(_ min _) - } - def cminOption(implicit o: Order[A]): Option[A] = - csumOption(new CommutativeSemigroup[A] { - def combine(l: A, r: A) = l min r - }) - - def cmax(implicit o: Order[A], e: Empty[A]): A = { - if (lhs.isEmpty) e.empty - else lhs.reduce(_ max _) - } - def cmaxOption(implicit o: Order[A]): Option[A] = - csumOption(new CommutativeSemigroup[A] { - def combine(l: A, r: A) = l max r - }) - } - - implicit class pairRddOps[K: ClassTag, V: ClassTag](lhs: RDD[(K, V)]) { - def csumByKey(implicit m: CommutativeSemigroup[V]): RDD[(K, V)] = lhs.reduceByKey(_ |+| _) - def cminByKey(implicit o: Order[V]): RDD[(K, V)] = lhs.reduceByKey(_ min _) - def cmaxByKey(implicit o: Order[V]): RDD[(K, V)] = lhs.reduceByKey(_ max _) - } -} - -object union { - implicit def unionSemigroup[A]: Semigroup[RDD[A]] = - new Semigroup[RDD[A]] { - def combine(lhs: RDD[A], rhs: RDD[A]): RDD[A] = lhs union rhs - } -} - -object inner { - implicit def pairwiseInnerSemigroup[K: ClassTag, V: ClassTag: Semigroup]: Semigroup[RDD[(K, V)]] = - new Semigroup[RDD[(K, V)]] { - def combine(lhs: RDD[(K, V)], rhs: RDD[(K, V)]): RDD[(K, V)] = - lhs.join(rhs).mapValues { case (x, y) => x |+| y } - } -} - -object outer { - implicit def pairwiseOuterSemigroup[K: ClassTag, V: ClassTag](implicit m: Monoid[V]): Semigroup[RDD[(K, V)]] = - new Semigroup[RDD[(K, V)]] { - def combine(lhs: RDD[(K, V)], rhs: RDD[(K, V)]): RDD[(K, V)] = - lhs.fullOuterJoin(rhs).mapValues { - case (Some(x), Some(y)) => x |+| y - case (None, Some(y)) => y - case (Some(x), None) => x - case (None, None) => m.empty - } - } -} diff --git a/cats/src/main/scala/frameless/cats/package.scala b/cats/src/main/scala/frameless/cats/package.scala deleted file mode 100644 index 9cc33513f..000000000 --- a/cats/src/main/scala/frameless/cats/package.scala +++ /dev/null @@ -1,9 +0,0 @@ -package frameless - -import _root_.cats.Id -import _root_.cats.data.Kleisli -import org.apache.spark.SparkContext - -package object cats { - type SparkTask[A] = Kleisli[Id, SparkContext, A] -} diff --git a/cats/src/test/resources/log4j.properties b/cats/src/test/resources/log4j.properties deleted file mode 100644 index 044f9440b..000000000 --- a/cats/src/test/resources/log4j.properties +++ /dev/null @@ -1,146 +0,0 @@ -log4j.logger.akka.event.slf4j.Slf4jLogger=ERROR -log4j.logger.akka.event.slf4j=ERROR -log4j.logger.akka.remote.EndpointWriter=ERROR -log4j.logger.akka.remote.RemoteActorRefProvider$RemotingTerminator=ERROR -log4j.logger.com.anjuke.dm=ERROR -log4j.logger.io.netty.bootstrap.ServerBootstrap=ERROR -log4j.logger.io.netty.buffer.ByteBufUtil=ERROR -log4j.logger.io.netty.buffer.PooledByteBufAllocator=ERROR -log4j.logger.io.netty.channel.AbstractChannel=ERROR -log4j.logger.io.netty.channel.ChannelInitializer=ERROR -log4j.logger.io.netty.channel.ChannelOutboundBuffer=ERROR -log4j.logger.io.netty.channel.DefaultChannelPipeline=ERROR -log4j.logger.io.netty.channel.MultithreadEventLoopGroup=ERROR -log4j.logger.io.netty.channel.nio.AbstractNioChannel=ERROR -log4j.logger.io.netty.channel.nio.NioEventLoop=ERROR -log4j.logger.io.netty.channel.socket.nio.NioServerSocketChannel=ERROR -log4j.logger.io.netty.util.concurrent.DefaultPromise.rejectedExecution=ERROR -log4j.logger.io.netty.util.concurrent.DefaultPromise=ERROR -log4j.logger.io.netty.util.concurrent.GlobalEventExecutor=ERROR -log4j.logger.io.netty.util.concurrent.SingleThreadEventExecutor=ERROR -log4j.logger.io.netty.util.internal.logging.InternalLoggerFactory=ERROR -log4j.logger.io.netty.util.internal.PlatformDependent0=ERROR -log4j.logger.io.netty.util.internal.PlatformDependent=ERROR -log4j.logger.io.netty.util.internal.SystemPropertyUtil=ERROR -log4j.logger.io.netty.util.internal.ThreadLocalRandom=ERROR -log4j.logger.io.netty.util.NetUtil=ERROR -log4j.logger.org.apache.hadoop.conf.Configuration.deprecation=ERROR -log4j.logger.org.apache.hadoop.conf.Configuration=ERROR -log4j.logger.org.apache.hadoop.fs.FileSystem=ERROR -log4j.logger.org.apache.hadoop.hive.metastore.RetryingHMSHandler=ERROR -log4j.logger.org.apache.hadoop.hive.ql.exec.FunctionRegistry=ERROR -log4j.logger.org.apache.hadoop.mapred.JobConf=ERROR -log4j.logger.org.apache.hadoop.mapreduce.lib.partition.KeyFieldBasedPartitioner=ERROR -log4j.logger.org.apache.hadoop.metrics2.impl.MetricsSystemImpl=ERROR -log4j.logger.org.apache.hadoop.metrics2.lib.Interns=ERROR -log4j.logger.org.apache.hadoop.metrics2.lib.MetricsSourceBuilder=ERROR -log4j.logger.org.apache.hadoop.metrics2.lib.MutableMetricsFactory=ERROR -log4j.logger.org.apache.hadoop.security.authentication.util.KerberosName=ERROR -log4j.logger.org.apache.hadoop.security.Groups=ERROR -log4j.logger.org.apache.hadoop.security.JniBasedUnixGroupsMappingWithFallback=ERROR -log4j.logger.org.apache.hadoop.security.SecurityUtil=ERROR -log4j.logger.org.apache.hadoop.security.ShellBasedUnixGroupsMapping=ERROR -log4j.logger.org.apache.hadoop.security.UserGroupInformation=ERROR -log4j.logger.org.apache.hadoop.util.NativeCodeLoader=ERROR -log4j.logger.org.apache.hadoop.util.ShutdownHookManager=ERROR -log4j.logger.org.apache.spark.broadcast.TorrentBroadcast=ERROR -log4j.logger.org.apache.spark.ContextCleaner=ERROR -log4j.logger.org.apache.spark.executor.Executor=ERROR -log4j.logger.org.apache.spark.HeartbeatReceiver=ERROR -log4j.logger.org.apache.spark.HttpFileServer=ERROR -log4j.logger.org.apache.spark.HttpServer=ERROR -log4j.logger.org.apache.spark.MapOutputTrackerMaster=ERROR -log4j.logger.org.apache.spark.MapOutputTrackerMasterEndpoint=ERROR -log4j.logger.org.apache.spark.metrics.MetricsSystem=ERROR -log4j.logger.org.apache.spark.network.client.TransportClientFactory=ERROR -log4j.logger.org.apache.spark.network.netty.NettyBlockTransferService=ERROR -log4j.logger.org.apache.spark.network.protocol.MessageDecoder=ERROR -log4j.logger.org.apache.spark.network.protocol.MessageEncoder=ERROR -log4j.logger.org.apache.spark.network.server.OneForOneStreamManager=ERROR -log4j.logger.org.apache.spark.network.server.TransportServer=ERROR -log4j.logger.org.apache.spark.network.TransportContext=ERROR -log4j.logger.org.apache.spark.network.util.JavaUtils=ERROR -log4j.logger.org.apache.spark.rdd.CoGroupedRDD=ERROR -log4j.logger.org.apache.spark.rdd.SubtractedRDD=ERROR -log4j.logger.org.apache.spark.repl.SparkILoop$SparkILoopInterpreter=ERROR -log4j.logger.org.apache.spark.repl.SparkIMain$exprTyper=ERROR -log4j.logger.org.apache.spark.rpc.akka.AkkaRpcEnv$$anonfun$actorRef$lzycompute$1$1$$anon$1=ERROR -log4j.logger.org.apache.spark.scheduler.DAGScheduler=ERROR -log4j.logger.org.apache.spark.scheduler.OutputCommitCoordinator$OutputCommitCoordinatorEndpoint=ERROR -log4j.logger.org.apache.spark.scheduler.TaskSchedulerImpl=ERROR -log4j.logger.org.apache.spark.scheduler.TaskSetManager=ERROR -log4j.logger.org.apache.spark.SecurityManager=ERROR -log4j.logger.org.apache.spark.shuffle.sort.BypassMergeSortShuffleWriter=ERROR -log4j.logger.org.apache.spark.SparkContext=ERROR -log4j.logger.org.apache.spark.SparkEnv=ERROR -log4j.logger.org.apache.spark.sql.catalyst.analysis.Analyzer$ResolveReferences=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GenerateMutableProjection=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GenerateOrdering=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GeneratePredicate=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GenerateProjection=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GenerateSafeProjection=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GenerateUnsafeProjection=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GenerateUnsafeRowJoiner=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.package$ExpressionCanonicalizer=ERROR -log4j.logger.org.apache.spark.sql.catalyst.optimizer.DefaultOptimizer=ERROR -log4j.logger.org.apache.spark.sql.catalyst.planning.ExtractEquiJoinKeys=ERROR -log4j.logger.org.apache.spark.sql.execution.aggregate.SortBasedAggregate=ERROR -log4j.logger.org.apache.spark.sql.execution.aggregate.TungstenAggregate=ERROR -log4j.logger.org.apache.spark.sql.execution.Exchange=ERROR -log4j.logger.org.apache.spark.sql.execution.joins.ShuffledHashOuterJoin=ERROR -log4j.logger.org.apache.spark.sql.SQLContext$$anon$1=ERROR -log4j.logger.org.apache.spark.sql.SQLContext$$anon$2=ERROR -log4j.logger.org.apache.spark.SSLOptions=ERROR -log4j.logger.org.apache.spark.storage.BlockManager=ERROR -log4j.logger.org.apache.spark.storage.BlockManagerInfo=ERROR -log4j.logger.org.apache.spark.storage.BlockManagerMaster=ERROR -log4j.logger.org.apache.spark.storage.BlockManagerMasterEndpoint=ERROR -log4j.logger.org.apache.spark.storage.BlockManagerSlaveEndpoint=ERROR -log4j.logger.org.apache.spark.storage.DiskBlockManager=ERROR -log4j.logger.org.apache.spark.storage.MemoryStore=ERROR -log4j.logger.org.apache.spark.storage.ShuffleBlockFetcherIterator=ERROR -log4j.logger.org.apache.spark.ui.SparkUI=ERROR -log4j.logger.org.apache.spark.unsafe.map.BytesToBytesMap=ERROR -log4j.logger.org.apache.spark.unsafe.memory.TaskMemoryManager=ERROR -log4j.logger.org.apache.spark.util.AkkaUtils=ERROR -log4j.logger.org.apache.spark.util.ClosureCleaner=ERROR -log4j.logger.org.apache.spark.util.collection.unsafe.sort.UnsafeExternalSorter=ERROR -log4j.logger.org.apache.spark.util.Utils=ERROR -log4j.logger.org.apache.spark=ERROR -log4j.logger.org.eclipse.jetty.util.component.AbstractLifeCycle=ERROR -log4j.logger.org.eclipse.jetty=ERROR -log4j.logger.org.spark-project.jetty.http.AbstractGenerator=ERROR -log4j.logger.org.spark-project.jetty.http.HttpGenerator=ERROR -log4j.logger.org.spark-project.jetty.http.MimeTypes=ERROR -log4j.logger.org.spark-project.jetty.io.AbstractBuffer=ERROR -log4j.logger.org.spark-project.jetty.io.nio=ERROR -log4j.logger.org.spark-project.jetty.server.AbstractConnector=ERROR -log4j.logger.org.spark-project.jetty.server.bio.SocketConnector=ERROR -log4j.logger.org.spark-project.jetty.server.handler.AbstractHandler=ERROR -log4j.logger.org.spark-project.jetty.server.handler.ContextHandler=ERROR -log4j.logger.org.spark-project.jetty.server.handler.ContextHandlerCollection=ERROR -log4j.logger.org.spark-project.jetty.server.handler.DefaultHandler=ERROR -log4j.logger.org.spark-project.jetty.server.handler.ErrorHandler=ERROR -log4j.logger.org.spark-project.jetty.server.handler.GzipHandler=ERROR -log4j.logger.org.spark-project.jetty.server.handler.ResourceHandler=ERROR -log4j.logger.org.spark-project.jetty.server.Server=ERROR -log4j.logger.org.spark-project.jetty.server=ERROR -log4j.logger.org.spark-project.jetty.servlet.DefaultServlet=ERROR -log4j.logger.org.spark-project.jetty.servlet.Holder=ERROR -log4j.logger.org.spark-project.jetty.servlet.ServletHandler=ERROR -log4j.logger.org.spark-project.jetty.servlet.ServletHolder=ERROR -log4j.logger.org.spark-project.jetty.util.component.AbstractLifeCycle=ERROR -log4j.logger.org.spark-project.jetty.util.component.AggregateLifeCycle=ERROR -log4j.logger.org.spark-project.jetty.util.component.Container=ERROR -log4j.logger.org.spark-project.jetty.util.IO=ERROR -log4j.logger.org.spark-project.jetty.util.log=ERROR -log4j.logger.org.spark-project.jetty.util.resource.FileResource=ERROR -log4j.logger.org.spark-project.jetty.util.resource.JarFileResource=ERROR -log4j.logger.org.spark-project.jetty.util.resource.JarResource=ERROR -log4j.logger.org.spark-project.jetty.util.resource.Resource=ERROR -log4j.logger.org.spark-project.jetty.util.resource.URLResource=ERROR -log4j.logger.org.spark-project.jetty.util.StringUtil=ERROR -log4j.logger.org.spark-project.jetty.util.thread.QueuedThreadPool=ERROR -log4j.logger.org.spark-project.jetty.util.thread.Timeout=ERROR -log4j.logger.org.spark-project.jetty=ERROR -log4j.logger.Remoting=ERROR diff --git a/cats/src/test/scala/frameless/cats/FramelessSyntaxTests.scala b/cats/src/test/scala/frameless/cats/FramelessSyntaxTests.scala deleted file mode 100644 index c549bb31a..000000000 --- a/cats/src/test/scala/frameless/cats/FramelessSyntaxTests.scala +++ /dev/null @@ -1,50 +0,0 @@ -package frameless -package cats - -import _root_.cats.data.ReaderT -import _root_.cats.effect.IO -import frameless.{ TypedDataset, TypedDatasetSuite, TypedEncoder, X2 } -import org.apache.spark.sql.SparkSession -import org.scalacheck.Prop, Prop._ - -class FramelessSyntaxTests extends TypedDatasetSuite { - override val sparkDelay = null - - def prop[A, B](data: Vector[X2[A, B]])( - implicit ev: TypedEncoder[X2[A, B]] - ): Prop = { - import implicits._ - - val dataset = TypedDataset.create(data).dataset - val dataframe = dataset.toDF() - - val typedDataset = dataset.typed - val typedDatasetFromDataFrame = dataframe.unsafeTyped[X2[A, B]] - - typedDataset.collect[IO]().unsafeRunSync().toVector ?= typedDatasetFromDataFrame.collect[IO]().unsafeRunSync().toVector - } - - test("dataset typed - toTyped") { - check(forAll(prop[Int, String] _)) - } - - test("properties can be read back") { - import implicits._ - import _root_.cats.implicits._ - import _root_.cats.mtl.implicits._ - - check { - forAll { (k:String, v: String) => - val scopedKey = "frameless.tests." + k - 1.pure[ReaderT[IO, SparkSession, *]].withLocalProperty(scopedKey,v).run(session).unsafeRunSync() - sc.getLocalProperty(scopedKey) ?= v - - 1.pure[ReaderT[IO, SparkSession, *]].withGroupId(v).run(session).unsafeRunSync() - sc.getLocalProperty("spark.jobGroup.id") ?= v - - 1.pure[ReaderT[IO, SparkSession, *]].withDescription(v).run(session).unsafeRunSync() - sc.getLocalProperty("spark.job.description") ?= v - } - } - } -} diff --git a/cats/src/test/scala/frameless/cats/test.scala b/cats/src/test/scala/frameless/cats/test.scala deleted file mode 100644 index ce866dfa0..000000000 --- a/cats/src/test/scala/frameless/cats/test.scala +++ /dev/null @@ -1,129 +0,0 @@ -package frameless -package cats - -import _root_.cats.Foldable -import _root_.cats.implicits._ - -import org.apache.spark.SparkContext -import org.apache.spark.sql.SparkSession -import org.apache.spark.rdd.RDD -import org.apache.spark.{SparkConf, SparkContext => SC} - -import org.scalatest.compatible.Assertion -import org.scalactic.anyvals.PosInt -import org.scalacheck.Arbitrary -import org.scalatestplus.scalacheck.ScalaCheckPropertyChecks -import Arbitrary._ - -import scala.collection.immutable.SortedMap -import scala.reflect.ClassTag -import org.scalatest.matchers.should.Matchers -import org.scalatest.propspec.AnyPropSpec - -trait SparkTests { - val appID: String = new java.util.Date().toString + math.floor(math.random * 10E4).toLong.toString - - val conf: SparkConf = new SparkConf() - .setMaster("local[*]") - .setAppName("test") - .set("spark.ui.enabled", "false") - .set("spark.app.id", appID) - - implicit def session: SparkSession = SparkSession.builder().config(conf).getOrCreate() - implicit def sc: SparkContext = session.sparkContext - - implicit class seqToRdd[A: ClassTag](seq: Seq[A])(implicit sc: SC) { - def toRdd: RDD[A] = sc.makeRDD(seq) - } -} - -object Tests { - def innerPairwise(mx: Map[String, Int], my: Map[String, Int], check: (Any, Any) => Assertion)(implicit sc: SC): Assertion = { - import frameless.cats.implicits._ - import frameless.cats.inner._ - val xs = sc.parallelize(mx.toSeq) - val ys = sc.parallelize(my.toSeq) - - val mz0 = (xs |+| ys).collectAsMap - val mz1 = (xs join ys).mapValues { case (x, y) => x |+| y }.collectAsMap - val mz2 = (for { (k, x) <- mx; y <- my.get(k) } yield (k, x + y)).toMap - check(mz0, mz1) - check(mz1, mz2) - - val zs = sc.parallelize(mx.values.toSeq) - check(xs.csumByKey.collectAsMap, mx) - check(zs.csum, zs.collect.sum) - - if (mx.nonEmpty) { - check(xs.cminByKey.collectAsMap, mx) - check(xs.cmaxByKey.collectAsMap, mx) - check(zs.cmin, zs.collect.min) - check(zs.cmax, zs.collect.max) - } else check(1, 1) - } -} - -class Test extends AnyPropSpec with Matchers with ScalaCheckPropertyChecks with SparkTests { - implicit override val generatorDrivenConfig = - PropertyCheckConfiguration(minSize = PosInt(10)) - - property("spark is working") { - sc.parallelize(Array(1, 2, 3)).collect shouldBe Array(1,2,3) - } - - property("inner pairwise monoid") { - // Make sure we have non-empty map - forAll { (xh: (String, Int), mx: Map[String, Int], yh: (String, Int), my: Map[String, Int]) => - Tests.innerPairwise(mx + xh, my + yh, _ shouldBe _) - } - } - - property("rdd simple numeric commutative semigroup") { - import frameless.cats.implicits._ - - forAll { seq: List[Int] => - val expectedSum = if (seq.isEmpty) None else Some(seq.sum) - val expectedMin = if (seq.isEmpty) None else Some(seq.min) - val expectedMax = if (seq.isEmpty) None else Some(seq.max) - - val rdd = seq.toRdd - - rdd.cmin shouldBe expectedMin.getOrElse(0) - rdd.cminOption shouldBe expectedMin - - rdd.cmax shouldBe expectedMax.getOrElse(0) - rdd.cmaxOption shouldBe expectedMax - - rdd.csum shouldBe expectedSum.getOrElse(0) - rdd.csumOption shouldBe expectedSum - } - } - - property("rdd of SortedMap[Int,Int] commutative monoid") { - import frameless.cats.implicits._ - forAll { seq: List[SortedMap[Int, Int]] => - val rdd = seq.toRdd - rdd.csum shouldBe Foldable[List].fold(seq) - } - } - - property("rdd tuple commutative semigroup example") { - import frameless.cats.implicits._ - forAll { seq: List[(Int, Int)] => - val expectedSum = if (seq.isEmpty) None else Some(Foldable[List].fold(seq)) - val rdd = seq.toRdd - - rdd.csum shouldBe expectedSum.getOrElse(0 -> 0) - rdd.csumOption shouldBe expectedSum - } - } - - property("pair rdd numeric commutative semigroup example") { - import frameless.cats.implicits._ - val seq = Seq( ("a",2), ("b",3), ("d",6), ("b",2), ("d",1) ) - val rdd = seq.toRdd - rdd.cminByKey.collect.toSeq should contain theSameElementsAs Seq( ("a",2), ("b",2), ("d",1) ) - rdd.cmaxByKey.collect.toSeq should contain theSameElementsAs Seq( ("a",2), ("b",3), ("d",6) ) - rdd.csumByKey.collect.toSeq should contain theSameElementsAs Seq( ("a",2), ("b",5), ("d",7) ) - } -} diff --git a/core/src/main/scala/frameless/CatalystAverageable.scala b/core/src/main/scala/frameless/CatalystAverageable.scala deleted file mode 100644 index 401ed65fc..000000000 --- a/core/src/main/scala/frameless/CatalystAverageable.scala +++ /dev/null @@ -1,26 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -/** - * When averaging Spark doesn't change these types: - * - BigDecimal -> BigDecimal - * - Double -> Double - * But it changes these types : - * - Int -> Double - * - Short -> Double - * - Long -> Double - */ -@implicitNotFound("Cannot compute average of type ${In}.") -trait CatalystAverageable[In, Out] - -object CatalystAverageable { - private[this] val theInstance = new CatalystAverageable[Any, Any] {} - private[this] def of[In, Out]: CatalystAverageable[In, Out] = theInstance.asInstanceOf[CatalystAverageable[In, Out]] - - implicit val framelessAverageableBigDecimal: CatalystAverageable[BigDecimal, BigDecimal] = of[BigDecimal, BigDecimal] - implicit val framelessAverageableDouble: CatalystAverageable[Double, Double] = of[Double, Double] - implicit val framelessAverageableLong: CatalystAverageable[Long, Double] = of[Long, Double] - implicit val framelessAverageableInt: CatalystAverageable[Int, Double] = of[Int, Double] - implicit val framelessAverageableShort: CatalystAverageable[Short, Double] = of[Short, Double] -} diff --git a/core/src/main/scala/frameless/CatalystBitShift.scala b/core/src/main/scala/frameless/CatalystBitShift.scala deleted file mode 100644 index 753a61907..000000000 --- a/core/src/main/scala/frameless/CatalystBitShift.scala +++ /dev/null @@ -1,20 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -/** Spark does not return always Int on shift - */ - -@implicitNotFound("Cannot do bit shift operations on columns of type ${In}.") -trait CatalystBitShift[In, Out] - -object CatalystBitShift { - private[this] val theInstance = new CatalystBitShift[Any, Any] {} - private[this] def of[In, Out]: CatalystBitShift[In, Out] = theInstance.asInstanceOf[CatalystBitShift[In, Out]] - - implicit val framelessBitShiftBigDecimal: CatalystBitShift[BigDecimal, Int] = of[BigDecimal, Int] - implicit val framelessBitShiftDouble : CatalystBitShift[Byte, Int] = of[Byte, Int] - implicit val framelessBitShiftInt : CatalystBitShift[Short, Int] = of[Short, Int] - implicit val framelessBitShiftLong : CatalystBitShift[Int, Int] = of[Int, Int] - implicit val framelessBitShiftShort : CatalystBitShift[Long, Long] = of[Long, Long] -} diff --git a/core/src/main/scala/frameless/CatalystBitwise.scala b/core/src/main/scala/frameless/CatalystBitwise.scala deleted file mode 100644 index c9eb8bcb8..000000000 --- a/core/src/main/scala/frameless/CatalystBitwise.scala +++ /dev/null @@ -1,20 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -/** Types that can be bitwise ORed, ANDed, or XORed by Catalyst. - * Note that Catalyst requires that when performing bitwise operations between columns - * the two types must be the same so in some cases casting is necessary. - */ -@implicitNotFound("Cannot do bitwise operations on columns of type ${A}.") -trait CatalystBitwise[A] extends CatalystNumeric[A] - -object CatalystBitwise { - private[this] val theInstance = new CatalystBitwise[Any] {} - private[this] def of[A]: CatalystBitwise[A] = theInstance.asInstanceOf[CatalystBitwise[A]] - - implicit val framelessbyteBitwise : CatalystBitwise[Byte] = of[Byte] - implicit val framelessshortBitwise : CatalystBitwise[Short] = of[Short] - implicit val framelessintBitwise : CatalystBitwise[Int] = of[Int] - implicit val framelesslongBitwise : CatalystBitwise[Long] = of[Long] -} diff --git a/core/src/main/scala/frameless/CatalystCast.scala b/core/src/main/scala/frameless/CatalystCast.scala deleted file mode 100644 index 1a8a21573..000000000 --- a/core/src/main/scala/frameless/CatalystCast.scala +++ /dev/null @@ -1,75 +0,0 @@ -package frameless - -trait CatalystCast[A, B] - -object CatalystCast { - private[this] val theInstance = new CatalystCast[Any, Any] {} - private[this] def of[A, B]: CatalystCast[A, B] = theInstance.asInstanceOf[CatalystCast[A, B]] - - implicit def framelessCastToString[T]: CatalystCast[T, String] = of[T, String] - - implicit def framelessNumericToLong [A: CatalystNumeric]: CatalystCast[A, Long] = of[A, Long] - implicit def framelessNumericToInt [A: CatalystNumeric]: CatalystCast[A, Int] = of[A, Int] - implicit def framelessNumericToShort [A: CatalystNumeric]: CatalystCast[A, Short] = of[A, Short] - implicit def framelessNumericToByte [A: CatalystNumeric]: CatalystCast[A, Byte] = of[A, Byte] - implicit def framelessNumericToDecimal[A: CatalystNumeric]: CatalystCast[A, BigDecimal] = of[A, BigDecimal] - implicit def framelessNumericToDouble [A: CatalystNumeric]: CatalystCast[A, Double] = of[A, Double] - - implicit def framelessBooleanToNumeric[A: CatalystNumeric]: CatalystCast[Boolean, A] = of[Boolean, A] - - // doesn't make any sense to include: - // - sqlDateToBoolean: always None - // - sqlTimestampToBoolean: compares us to 0 - implicit val framelessStringToBoolean : CatalystCast[String, Option[Boolean]] = of[String, Option[Boolean]] - implicit val framelessLongToBoolean : CatalystCast[Long, Boolean] = of[Long, Boolean] - implicit val framelessIntToBoolean : CatalystCast[Int, Boolean] = of[Int, Boolean] - implicit val framelessShortToBoolean : CatalystCast[Short, Boolean] = of[Short, Boolean] - implicit val framelessByteToBoolean : CatalystCast[Byte, Boolean] = of[Byte, Boolean] - implicit val framelessBigDecimalToBoolean: CatalystCast[BigDecimal, Boolean] = of[BigDecimal, Boolean] - implicit val framelessDoubleToBoolean : CatalystCast[Double, Boolean] = of[Double, Boolean] - - // TODO - - // needs verification, does it make sense to include? probably better as a separate function - // implicit object stringToInt extends CatalystCast[String, Option[Int]] - // implicit object stringToShort extends CatalystCast[String, Option[Short]] - // implicit object stringToByte extends CatalystCast[String, Option[Byte]] - // implicit object stringToDecimal extends CatalystCast[String, Option[BigDecimal]] - // implicit object stringToLong extends CatalystCast[String, Option[Long]] - // implicit object stringToSqlDate extends CatalystCast[String, Option[SQLDate]] - - - // needs verification: - //implicit object sqlTimestampToSqlDate extends CatalystCast[SQLTimestamp, SQLDate] - - // needs verification: - // implicit object sqlTimestampToDecimal extends CatalystCast[SQLTimestamp, BigDecimal] - // implicit object sqlTimestampToLong extends CatalystCast[SQLTimestamp, Long] - - // needs verification: - // implicit object stringToSqlTimestamp extends CatalystCast[String, SQLTimestamp] - // implicit object longToSqlTimestamp extends CatalystCast[Long, SQLTimestamp] - // implicit object intToSqlTimestamp extends CatalystCast[Int, SQLTimestamp] - // implicit object doubleToSqlTimestamp extends CatalystCast[Double, SQLTimestamp] - // implicit object floatToSqlTimestamp extends CatalystCast[Float, SQLTimestamp] - // implicit object bigDecimalToSqlTimestamp extends CatalystCast[BigDecimal, SQLTimestamp] - // implicit object sqlDateToSqlTimestamp extends CatalystCast[SQLDate, SQLTimestamp] - - // doesn't make sense to include: - // - booleanToSqlTimestamp: 1L or 0L - // - shortToSqlTimestamp: ??? - // - byteToSqlTimestamp: ??? - - // doesn't make sense to include: - // - sqlDateToLong: always None - // - sqlDateToInt: always None - // - sqlDateToInt: always None - // - sqlDateToInt: always None - // - sqlDateToInt: always None - - // doesn't make sense to include: - // - sqlTimestampToInt: useful? can be done through `-> Long -> Int` - // - sqlTimestampToShort: useful? can be done through `-> Long -> Int` - // - sqlTimestampToShort: useful? can be done through `-> Long -> Int` - -} diff --git a/core/src/main/scala/frameless/CatalystCollection.scala b/core/src/main/scala/frameless/CatalystCollection.scala deleted file mode 100644 index 3456869a0..000000000 --- a/core/src/main/scala/frameless/CatalystCollection.scala +++ /dev/null @@ -1,16 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -@implicitNotFound("Cannot do collection operations on columns of type ${C}.") -trait CatalystCollection[C[_]] - -object CatalystCollection { - private[this] val theInstance = new CatalystCollection[Any] {} - private[this] def of[A[_]]: CatalystCollection[A] = theInstance.asInstanceOf[CatalystCollection[A]] - - implicit val arrayObject : CatalystCollection[Array] = of[Array] - implicit val seqObject : CatalystCollection[Seq] = of[Seq] - implicit val listObject : CatalystCollection[List] = of[List] - implicit val vectorObject: CatalystCollection[Vector] = of[Vector] -} diff --git a/core/src/main/scala/frameless/CatalystDivisible.scala b/core/src/main/scala/frameless/CatalystDivisible.scala deleted file mode 100644 index c9080a5d8..000000000 --- a/core/src/main/scala/frameless/CatalystDivisible.scala +++ /dev/null @@ -1,21 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -/** Spark divides everything as Double, expect BigDecimals are divided into - * another BigDecimal, benefiting from some added precision. - */ -@implicitNotFound("Cannot compute division on type ${In}.") -trait CatalystDivisible[In, Out] - -object CatalystDivisible { - private[this] val theInstance = new CatalystDivisible[Any, Any] {} - private[this] def of[In, Out]: CatalystDivisible[In, Out] = theInstance.asInstanceOf[CatalystDivisible[In, Out]] - - implicit val framelessDivisibleBigDecimal: CatalystDivisible[BigDecimal, BigDecimal] = of[BigDecimal, BigDecimal] - implicit val framelessDivisibleDouble : CatalystDivisible[Double, Double] = of[Double, Double] - implicit val framelessDivisibleInt : CatalystDivisible[Int, Double] = of[Int, Double] - implicit val framelessDivisibleLong : CatalystDivisible[Long, Double] = of[Long, Double] - implicit val framelessDivisibleByte : CatalystDivisible[Byte, Double] = of[Byte, Double] - implicit val framelessDivisibleShort : CatalystDivisible[Short, Double] = of[Short, Double] -} diff --git a/core/src/main/scala/frameless/CatalystIsin.scala b/core/src/main/scala/frameless/CatalystIsin.scala deleted file mode 100644 index f630a7155..000000000 --- a/core/src/main/scala/frameless/CatalystIsin.scala +++ /dev/null @@ -1,18 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -/** Types for which we can check if is in */ -@implicitNotFound("Cannot do isin operation on columns of type ${A}.") -trait CatalystIsin[A] - -object CatalystIsin { - implicit object framelessBigDecimal extends CatalystIsin[BigDecimal] - implicit object framelessByte extends CatalystIsin[Byte] - implicit object framelessDouble extends CatalystIsin[Double] - implicit object framelessFloat extends CatalystIsin[Float] - implicit object framelessInt extends CatalystIsin[Int] - implicit object framelessLong extends CatalystIsin[Long] - implicit object framelessShort extends CatalystIsin[Short] - implicit object framelesssString extends CatalystIsin[String] -} diff --git a/core/src/main/scala/frameless/CatalystNaN.scala b/core/src/main/scala/frameless/CatalystNaN.scala deleted file mode 100644 index 3e7be8263..000000000 --- a/core/src/main/scala/frameless/CatalystNaN.scala +++ /dev/null @@ -1,16 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -/** Spark does NaN check only for these types */ -@implicitNotFound("Columns of type ${A} cannot be NaN.") -trait CatalystNaN[A] - -object CatalystNaN { - private[this] val theInstance = new CatalystNaN[Any] {} - private[this] def of[A]: CatalystNaN[A] = theInstance.asInstanceOf[CatalystNaN[A]] - - implicit val framelessFloatNaN : CatalystNaN[Float] = of[Float] - implicit val framelessDoubleNaN : CatalystNaN[Double] = of[Double] -} - diff --git a/core/src/main/scala/frameless/CatalystNotNullable.scala b/core/src/main/scala/frameless/CatalystNotNullable.scala deleted file mode 100644 index e8d4b3be1..000000000 --- a/core/src/main/scala/frameless/CatalystNotNullable.scala +++ /dev/null @@ -1,18 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -@implicitNotFound("Cannot find evidence that type ${A} is nullable. Currently, only Option[A] is nullable.") -trait CatalystNullable[A] - -object CatalystNullable { - implicit def optionIsNullable[A]: CatalystNullable[Option[A]] = new CatalystNullable[Option[A]] {} -} - -@implicitNotFound("Cannot find evidence that type ${A} is not nullable.") -trait NotCatalystNullable[A] - -object NotCatalystNullable { - implicit def everythingIsNotNullable[A]: NotCatalystNullable[A] = new NotCatalystNullable[A] {} - implicit def nullableIsNotNotNullable[A: CatalystNullable]: NotCatalystNullable[A] = new NotCatalystNullable[A] {} -} diff --git a/core/src/main/scala/frameless/CatalystNumeric.scala b/core/src/main/scala/frameless/CatalystNumeric.scala deleted file mode 100644 index c819ba2ae..000000000 --- a/core/src/main/scala/frameless/CatalystNumeric.scala +++ /dev/null @@ -1,19 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -/** Types that can be added, subtracted and multiplied by Catalyst. */ -@implicitNotFound("Cannot do numeric operations on columns of type ${A}.") -trait CatalystNumeric[A] - -object CatalystNumeric { - private[this] val theInstance = new CatalystNumeric[Any] {} - private[this] def of[A]: CatalystNumeric[A] = theInstance.asInstanceOf[CatalystNumeric[A]] - - implicit val framelessbigDecimalNumeric: CatalystNumeric[BigDecimal] = of[BigDecimal] - implicit val framelessbyteNumeric : CatalystNumeric[Byte] = of[Byte] - implicit val framelessdoubleNumeric : CatalystNumeric[Double] = of[Double] - implicit val framelessintNumeric : CatalystNumeric[Int] = of[Int] - implicit val framelesslongNumeric : CatalystNumeric[Long] = of[Long] - implicit val framelessshortNumeric : CatalystNumeric[Short] = of[Short] -} diff --git a/core/src/main/scala/frameless/CatalystNumericWithJavaBigDecimal.scala b/core/src/main/scala/frameless/CatalystNumericWithJavaBigDecimal.scala deleted file mode 100644 index 8fee63be2..000000000 --- a/core/src/main/scala/frameless/CatalystNumericWithJavaBigDecimal.scala +++ /dev/null @@ -1,21 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -/** Spark does not return always the same type as the input was for example abs - */ -@implicitNotFound("Cannot compute on type ${In}.") -trait CatalystNumericWithJavaBigDecimal[In, Out] - -object CatalystNumericWithJavaBigDecimal { - private[this] val theInstance = new CatalystNumericWithJavaBigDecimal[Any, Any] {} - private[this] def of[In, Out]: CatalystNumericWithJavaBigDecimal[In, Out] = theInstance.asInstanceOf[CatalystNumericWithJavaBigDecimal[In, Out]] - - implicit val framelessAbsoluteBigDecimal: CatalystNumericWithJavaBigDecimal[BigDecimal, java.math.BigDecimal] = of[BigDecimal, java.math.BigDecimal] - implicit val framelessAbsoluteDouble : CatalystNumericWithJavaBigDecimal[Double, Double] = of[Double, Double] - implicit val framelessAbsoluteInt : CatalystNumericWithJavaBigDecimal[Int, Int] = of[Int, Int] - implicit val framelessAbsoluteLong : CatalystNumericWithJavaBigDecimal[Long, Long] = of[Long, Long] - implicit val framelessAbsoluteShort : CatalystNumericWithJavaBigDecimal[Short, Short] = of[Short, Short] - implicit val framelessAbsoluteByte : CatalystNumericWithJavaBigDecimal[Byte, Byte] = of[Byte, Byte] - -} \ No newline at end of file diff --git a/core/src/main/scala/frameless/CatalystOrdered.scala b/core/src/main/scala/frameless/CatalystOrdered.scala deleted file mode 100644 index 4943e09f7..000000000 --- a/core/src/main/scala/frameless/CatalystOrdered.scala +++ /dev/null @@ -1,38 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound -import shapeless.{Generic, HList, Lazy} -import shapeless.ops.hlist.LiftAll - -/** Types that can be ordered/compared by Catalyst. */ -@implicitNotFound("Cannot compare columns of type ${A}.") -trait CatalystOrdered[A] - -object CatalystOrdered { - private[this] val theInstance = new CatalystOrdered[Any] {} - private[this] def of[A]: CatalystOrdered[A] = theInstance.asInstanceOf[CatalystOrdered[A]] - - implicit val framelessIntOrdered : CatalystOrdered[Int] = of[Int] - implicit val framelessBooleanOrdered : CatalystOrdered[Boolean] = of[Boolean] - implicit val framelessByteOrdered : CatalystOrdered[Byte] = of[Byte] - implicit val framelessShortOrdered : CatalystOrdered[Short] = of[Short] - implicit val framelessLongOrdered : CatalystOrdered[Long] = of[Long] - implicit val framelessFloatOrdered : CatalystOrdered[Float] = of[Float] - implicit val framelessDoubleOrdered : CatalystOrdered[Double] = of[Double] - implicit val framelessBigDecimalOrdered : CatalystOrdered[BigDecimal] = of[BigDecimal] - implicit val framelessSQLDateOrdered : CatalystOrdered[SQLDate] = of[SQLDate] - implicit val framelessSQLTimestampOrdered: CatalystOrdered[SQLTimestamp] = of[SQLTimestamp] - implicit val framelessStringOrdered : CatalystOrdered[String] = of[String] - - implicit def injectionOrdered[A, B] - (implicit - i0: Injection[A, B], - i1: CatalystOrdered[B] - ): CatalystOrdered[A] = of[A] - - implicit def deriveGeneric[G, H <: HList] - (implicit - i0: Generic.Aux[G, H], - i1: Lazy[LiftAll[CatalystOrdered, H]] - ): CatalystOrdered[G] = of[G] -} diff --git a/core/src/main/scala/frameless/CatalystPivotable.scala b/core/src/main/scala/frameless/CatalystPivotable.scala deleted file mode 100644 index a7b34da64..000000000 --- a/core/src/main/scala/frameless/CatalystPivotable.scala +++ /dev/null @@ -1,16 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -@implicitNotFound("Cannot pivot on type ${A}. Currently supported types to pivot are {Int, Long, Boolean, and String}.") -trait CatalystPivotable[A] - -object CatalystPivotable { - private[this] val theInstance = new CatalystPivotable[Any] {} - private[this] def of[A]: CatalystPivotable[A] = theInstance.asInstanceOf[CatalystPivotable[A]] - - implicit val framelessIntPivotable : CatalystPivotable[Int] = of[Int] - implicit val framelessLongPivotable : CatalystPivotable[Long] = of[Long] - implicit val framelessBooleanPivotable: CatalystPivotable[Boolean] = of[Boolean] - implicit val framelessStringPivotable : CatalystPivotable[String] = of[String] -} diff --git a/core/src/main/scala/frameless/CatalystRound.scala b/core/src/main/scala/frameless/CatalystRound.scala deleted file mode 100644 index ee50b794a..000000000 --- a/core/src/main/scala/frameless/CatalystRound.scala +++ /dev/null @@ -1,19 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -/** Spark does not return always long on round - */ -@implicitNotFound("Cannot compute round on type ${In}.") -trait CatalystRound[In, Out] - -object CatalystRound { - private[this] val theInstance = new CatalystRound[Any, Any] {} - private[this] def of[In, Out]: CatalystRound[In, Out] = theInstance.asInstanceOf[CatalystRound[In, Out]] - - implicit val framelessBigDecimal: CatalystRound[BigDecimal, java.math.BigDecimal] = of[BigDecimal, java.math.BigDecimal] - implicit val framelessDouble : CatalystRound[Double, Long] = of[Double, Long] - implicit val framelessInt : CatalystRound[Int, Long] = of[Int, Long] - implicit val framelessLong : CatalystRound[Long, Long] = of[Long, Long] - implicit val framelessShort : CatalystRound[Short, Long] = of[Short, Long] -} \ No newline at end of file diff --git a/core/src/main/scala/frameless/CatalystSummable.scala b/core/src/main/scala/frameless/CatalystSummable.scala deleted file mode 100644 index 94010505e..000000000 --- a/core/src/main/scala/frameless/CatalystSummable.scala +++ /dev/null @@ -1,31 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -/** - * When summing Spark doesn't change these types: - * - Long -> Long - * - BigDecimal -> BigDecimal - * - Double -> Double - * - * For other types there are conversions: - * - Int -> Long - * - Short -> Long - */ -@implicitNotFound("Cannot compute sum of type ${In}.") -trait CatalystSummable[In, Out] { - def zero: In -} - -object CatalystSummable { - def apply[In, Out](zero: In): CatalystSummable[In, Out] = { - val _zero = zero - new CatalystSummable[In, Out] { val zero: In = _zero } - } - - implicit val framelessSummableLong : CatalystSummable[Long, Long] = CatalystSummable(zero = 0L) - implicit val framelessSummableBigDecimal: CatalystSummable[BigDecimal, BigDecimal] = CatalystSummable(zero = BigDecimal(0)) - implicit val framelessSummableDouble : CatalystSummable[Double, Double] = CatalystSummable(zero = 0.0) - implicit val framelessSummableInt : CatalystSummable[Int, Long] = CatalystSummable(zero = 0) - implicit val framelessSummableShort : CatalystSummable[Short, Long] = CatalystSummable(zero = 0) -} diff --git a/core/src/main/scala/frameless/CatalystVariance.scala b/core/src/main/scala/frameless/CatalystVariance.scala deleted file mode 100644 index 9e843fa70..000000000 --- a/core/src/main/scala/frameless/CatalystVariance.scala +++ /dev/null @@ -1,20 +0,0 @@ -package frameless - -import scala.annotation.implicitNotFound - -/** - * Spark's variance and stddev functions always return Double - */ -@implicitNotFound("Cannot compute variance on type ${A}.") -trait CatalystVariance[A] - -object CatalystVariance { - private[this] val theInstance = new CatalystVariance[Any] {} - private[this] def of[A]: CatalystVariance[A] = theInstance.asInstanceOf[CatalystVariance[A]] - - implicit val framelessIntVariance : CatalystVariance[Int] = of[Int] - implicit val framelessLongVariance : CatalystVariance[Long] = of[Long] - implicit val framelessShortVariance : CatalystVariance[Short] = of[Short] - implicit val framelessBigDecimalVariance: CatalystVariance[BigDecimal] = of[BigDecimal] - implicit val framelessDoubleVariance : CatalystVariance[Double] = of[Double] -} diff --git a/core/src/main/scala/frameless/Injection.scala b/core/src/main/scala/frameless/Injection.scala deleted file mode 100644 index 8f765c1ad..000000000 --- a/core/src/main/scala/frameless/Injection.scala +++ /dev/null @@ -1,17 +0,0 @@ -package frameless - -/** An Injection[A, B] is a reversible function from A to B. - * - * Must obey `forAll { a: A => invert(apply(a)) == a }`. - */ -trait Injection[A, B] extends Serializable { - def apply(a: A): B - def invert(b: B): A -} - -object Injection { - def apply[A, B](f: A => B, g: B => A): Injection[A, B] = new Injection[A, B] { - def apply(a: A): B = f(a) - def invert(b: B): A = g(b) - } -} diff --git a/core/src/main/scala/frameless/SQLDate.scala b/core/src/main/scala/frameless/SQLDate.scala deleted file mode 100644 index 47d66d872..000000000 --- a/core/src/main/scala/frameless/SQLDate.scala +++ /dev/null @@ -1,9 +0,0 @@ -package frameless - -/** - * Type for the internal Spark representation of SQL date. If the `spark.sql.functions` where typed, - * [date_add][1] would for instance be defined as `def date_add(d: SQLDate, i: Int); SQLDate`. - * - * [1]: https://spark.apache.org/docs/2.0.2/api/java/org/apache/spark/sql/functions.html#add_months(org.apache.spark.sql.Column,%20int) - */ -case class SQLDate(days: Int) diff --git a/core/src/main/scala/frameless/SQLTimestamp.scala b/core/src/main/scala/frameless/SQLTimestamp.scala deleted file mode 100644 index eb10bb26a..000000000 --- a/core/src/main/scala/frameless/SQLTimestamp.scala +++ /dev/null @@ -1,9 +0,0 @@ -package frameless - -/** - * Type for the Spark internal representation of a timestamp. If the `spark.sql.functions` where typed, - * [current_timestamp][1] would for instance be defined as `def current_timestamp(): SQLTimestamp`. - * - * [1]: https://spark.apache.org/docs/1.6.2/api/java/org/apache/spark/sql/functions.html#current_timestamp() - */ -case class SQLTimestamp(us: Long) diff --git a/dataset/src/main/scala/frameless/FramelessSyntax.scala b/dataset/src/main/scala/frameless/FramelessSyntax.scala deleted file mode 100644 index 5ba294921..000000000 --- a/dataset/src/main/scala/frameless/FramelessSyntax.scala +++ /dev/null @@ -1,18 +0,0 @@ -package frameless - -import org.apache.spark.sql.{Column, DataFrame, Dataset} - -trait FramelessSyntax { - implicit class ColumnSyntax(self: Column) { - def typedColumn[T, U: TypedEncoder]: TypedColumn[T, U] = new TypedColumn[T, U](self) - def typedAggregate[T, U: TypedEncoder]: TypedAggregate[T, U] = new TypedAggregate[T, U](self) - } - - implicit class DatasetSyntax[T: TypedEncoder](self: Dataset[T]) { - def typed: TypedDataset[T] = TypedDataset.create[T](self) - } - - implicit class DataframeSyntax(self: DataFrame){ - def unsafeTyped[T: TypedEncoder]: TypedDataset[T] = TypedDataset.createUnsafe(self) - } -} diff --git a/dataset/src/main/scala/frameless/Job.scala b/dataset/src/main/scala/frameless/Job.scala deleted file mode 100644 index 40931b8b4..000000000 --- a/dataset/src/main/scala/frameless/Job.scala +++ /dev/null @@ -1,44 +0,0 @@ -package frameless - -import org.apache.spark.sql.SparkSession - -sealed abstract class Job[A](implicit spark: SparkSession) { self => - /** Runs a new Spark job. */ - def run(): A - - def withGroupId(groupId: String): Job[A] = { - withLocalProperty("spark.jobGroup.id", groupId) - } - - def withDescription(groupId: String): Job[A] = { - withLocalProperty("spark.job.description", groupId) - } - - def withLocalProperty(key: String, value: String): Job[A] = { - new Job[A] { - def run(): A = { - spark.sparkContext.setLocalProperty(key, value) - self.run() - } - } - } - - def map[B](fn: A => B): Job[B] = new Job[B]()(spark) { - def run(): B = fn(Job.this.run()) - } - - def flatMap[B](fn: A => Job[B]): Job[B] = new Job[B]()(spark) { - def run(): B = fn(Job.this.run()).run() - } -} - - -object Job { - def apply[A](a: => A)(implicit spark: SparkSession): Job[A] = new Job[A] { - def run(): A = a - } - - implicit val framelessSparkDelayForJob: SparkDelay[Job] = new SparkDelay[Job] { - def delay[A](a: => A)(implicit spark: SparkSession): Job[A] = Job(a) - } -} diff --git a/dataset/src/main/scala/frameless/RecordEncoder.scala b/dataset/src/main/scala/frameless/RecordEncoder.scala deleted file mode 100644 index 0beaba5b3..000000000 --- a/dataset/src/main/scala/frameless/RecordEncoder.scala +++ /dev/null @@ -1,173 +0,0 @@ -package frameless - -import org.apache.spark.sql.FramelessInternals -import org.apache.spark.sql.catalyst.expressions._ -import org.apache.spark.sql.catalyst.expressions.objects.{Invoke, NewInstance} -import org.apache.spark.sql.types._ -import shapeless._ -import shapeless.labelled.FieldType -import shapeless.ops.hlist.IsHCons - -import scala.reflect.ClassTag - -case class RecordEncoderField( - ordinal: Int, - name: String, - encoder: TypedEncoder[_] -) - -trait RecordEncoderFields[T <: HList] extends Serializable { - def value: List[RecordEncoderField] -} - -object RecordEncoderFields { - - implicit def deriveRecordLast[K <: Symbol, H] - (implicit - key: Witness.Aux[K], - head: TypedEncoder[H] - ): RecordEncoderFields[FieldType[K, H] :: HNil] = new RecordEncoderFields[FieldType[K, H] :: HNil] { - def value: List[RecordEncoderField] = RecordEncoderField(0, key.value.name, head) :: Nil - } - - implicit def deriveRecordCons[K <: Symbol, H, T <: HList] - (implicit - key: Witness.Aux[K], - head: TypedEncoder[H], - tail: RecordEncoderFields[T] - ): RecordEncoderFields[FieldType[K, H] :: T] = new RecordEncoderFields[FieldType[K, H] :: T] { - def value: List[RecordEncoderField] = { - val fieldName = key.value.name - val fieldEncoder = RecordEncoderField(0, fieldName, head) - - fieldEncoder :: tail.value.map(x => x.copy(ordinal = x.ordinal + 1)) - } - } -} - -/** - * Assists the generation of constructor call parameters from a labelled generic representation. - * As Unit typed fields were removed earlier, we need to put back unit literals in the appropriate positions. - * - * @tparam T labelled generic representation of type fields - */ -trait NewInstanceExprs[T <: HList] extends Serializable { - def from(exprs: List[Expression]): Seq[Expression] -} - -object NewInstanceExprs { - - implicit def deriveHNil: NewInstanceExprs[HNil] = new NewInstanceExprs[HNil] { - def from(exprs: List[Expression]): Seq[Expression] = Nil - } - - implicit def deriveUnit[K <: Symbol, T <: HList] - (implicit - tail: NewInstanceExprs[T] - ): NewInstanceExprs[FieldType[K, Unit] :: T] = new NewInstanceExprs[FieldType[K, Unit] :: T] { - def from(exprs: List[Expression]): Seq[Expression] = - Literal.fromObject(()) +: tail.from(exprs) - } - - implicit def deriveNonUnit[K <: Symbol, V , T <: HList] - (implicit - notUnit: V =:!= Unit, - tail: NewInstanceExprs[T] - ): NewInstanceExprs[FieldType[K, V] :: T] = new NewInstanceExprs[FieldType[K, V] :: T] { - def from(exprs: List[Expression]): Seq[Expression] = exprs.head +: tail.from(exprs.tail) - } -} - -/** - * Drops fields with Unit type from labelled generic representation of types. - * - * @tparam L labelled generic representation of type fields - */ -trait DropUnitValues[L <: HList] extends DepFn1[L] with Serializable { type Out <: HList } - -object DropUnitValues { - def apply[L <: HList](implicit dropUnitValues: DropUnitValues[L]): Aux[L, dropUnitValues.Out] = dropUnitValues - - type Aux[L <: HList, Out0 <: HList] = DropUnitValues[L] { type Out = Out0 } - - implicit def deriveHNil[H]: Aux[HNil, HNil] = new DropUnitValues[HNil] { - type Out = HNil - def apply(l: HNil): Out = HNil - } - - implicit def deriveUnit[K <: Symbol, T <: HList, OutT <: HList] - (implicit - dropUnitValues : DropUnitValues.Aux[T, OutT] - ): Aux[FieldType[K, Unit] :: T, OutT] = new DropUnitValues[FieldType[K, Unit] :: T] { - type Out = OutT - def apply(l : FieldType[K, Unit] :: T): Out = dropUnitValues(l.tail) - } - - implicit def deriveNonUnit[K <: Symbol, V, T <: HList, OutH, OutT <: HList] - (implicit - nonUnit: V =:!= Unit, - dropUnitValues : DropUnitValues.Aux[T, OutT] - ): Aux[FieldType[K, V] :: T, FieldType[K, V] :: OutT] = new DropUnitValues[FieldType[K, V] :: T] { - type Out = FieldType[K, V] :: OutT - def apply(l : FieldType[K, V] :: T): Out = l.head :: dropUnitValues(l.tail) - } -} - -class RecordEncoder[F, G <: HList, H <: HList] - (implicit - i0: LabelledGeneric.Aux[F, G], - i1: DropUnitValues.Aux[G, H], - i2: IsHCons[H], - fields: Lazy[RecordEncoderFields[H]], - newInstanceExprs: Lazy[NewInstanceExprs[G]], - classTag: ClassTag[F] - ) extends TypedEncoder[F] { - def nullable: Boolean = false - - def jvmRepr: DataType = FramelessInternals.objectTypeFor[F] - - def catalystRepr: DataType = { - val structFields = fields.value.value.map { field => - StructField( - name = field.name, - dataType = field.encoder.catalystRepr, - nullable = field.encoder.nullable, - metadata = Metadata.empty - ) - } - - StructType(structFields) - } - - def toCatalyst(path: Expression): Expression = { - val nameExprs = fields.value.value.map { field => - Literal(field.name) - } - - val valueExprs = fields.value.value.map { field => - val fieldPath = Invoke(path, field.name, field.encoder.jvmRepr, Nil) - field.encoder.toCatalyst(fieldPath) - } - - // the way exprs are encoded in CreateNamedStruct - val exprs = nameExprs.zip(valueExprs).flatMap { - case (nameExpr, valueExpr) => nameExpr :: valueExpr :: Nil - } - - val createExpr = CreateNamedStruct(exprs) - val nullExpr = Literal.create(null, createExpr.dataType) - If(IsNull(path), nullExpr, createExpr) - } - - def fromCatalyst(path: Expression): Expression = { - val exprs = fields.value.value.map { field => - field.encoder.fromCatalyst( GetStructField(path, field.ordinal, Some(field.name)) ) - } - - val newArgs = newInstanceExprs.value.from(exprs) - val newExpr = NewInstance(classTag.runtimeClass, newArgs, jvmRepr, propagateNull = true) - - val nullExpr = Literal.create(null, jvmRepr) - If(IsNull(path), nullExpr, newExpr) - } -} diff --git a/dataset/src/main/scala/frameless/SparkDelay.scala b/dataset/src/main/scala/frameless/SparkDelay.scala deleted file mode 100644 index 74a651ae3..000000000 --- a/dataset/src/main/scala/frameless/SparkDelay.scala +++ /dev/null @@ -1,7 +0,0 @@ -package frameless - -import org.apache.spark.sql.SparkSession - -trait SparkDelay[F[_]] { - def delay[A](a: => A)(implicit spark: SparkSession): F[A] -} diff --git a/dataset/src/main/scala/frameless/TypedColumn.scala b/dataset/src/main/scala/frameless/TypedColumn.scala deleted file mode 100644 index c96550b6c..000000000 --- a/dataset/src/main/scala/frameless/TypedColumn.scala +++ /dev/null @@ -1,908 +0,0 @@ -package frameless - -import frameless.functions.{litAggr, lit => flit} -import frameless.syntax._ -import org.apache.spark.sql.catalyst.expressions._ -import org.apache.spark.sql.types.DecimalType -import org.apache.spark.sql.{Column, FramelessInternals} -import shapeless._ -import shapeless.ops.record.Selector - -import scala.annotation.implicitNotFound -import scala.reflect.ClassTag - -sealed trait UntypedExpression[T] { - def expr: Expression - def uencoder: TypedEncoder[_] - override def toString: String = expr.toString() -} - -/** Expression used in `select`-like constructions. - */ -sealed class TypedColumn[T, U](expr: Expression)( - implicit val uenc: TypedEncoder[U] -) extends AbstractTypedColumn[T, U](expr) { - - type ThisType[A, B] = TypedColumn[A, B] - - def this(column: Column)(implicit uencoder: TypedEncoder[U]) { - this(FramelessInternals.expr(column)) - } - - override def typed[W, U1: TypedEncoder](c: Column): TypedColumn[W, U1] = c.typedColumn - override def lit[U1: TypedEncoder](c: U1): TypedColumn[T,U1] = flit(c) -} - -/** Expression used in `agg`-like constructions. - */ -sealed class TypedAggregate[T, U](expr: Expression)( - implicit val uenc: TypedEncoder[U] -) extends AbstractTypedColumn[T, U](expr) { - - type ThisType[A, B] = TypedAggregate[A, B] - - def this(column: Column)(implicit uencoder: TypedEncoder[U]) { - this(FramelessInternals.expr(column)) - } - - override def typed[W, U1: TypedEncoder](c: Column): TypedAggregate[W, U1] = c.typedAggregate - override def lit[U1: TypedEncoder](c: U1): TypedAggregate[T, U1] = litAggr(c) -} - -/** Generic representation of a typed column. A typed column can either be a [[TypedAggregate]] or - * a [[frameless.TypedColumn]]. - * - * Documentation marked "apache/spark" is thanks to apache/spark Contributors - * at https://github.com/apache/spark, licensed under Apache v2.0 available at - * http://www.apache.org/licenses/LICENSE-2.0 - * - * @tparam T phantom type representing the dataset on which this columns is - * selected. When `T = A with B` the selection is on either A or B. - * @tparam U type of column - */ -abstract class AbstractTypedColumn[T, U] - (val expr: Expression) - (implicit val uencoder: TypedEncoder[U]) - extends UntypedExpression[T] { self => - - type ThisType[A, B] <: AbstractTypedColumn[A, B] - - /** A helper class to make to simplify working with Optional fields. - * - * {{{ - * val x: TypedColumn[Option[Int]] = _ - * x.opt.map(_*2) // This only compiles if the type of x is Option[X] (in this example X is of type Int) - * }}} - * - * @note Known issue: map() will NOT work when the applied function is a udf(). - * It will compile and then throw a runtime error. - **/ - trait Mapper[X] { - def map[G, OutputType[_,_]](u: ThisType[T, X] => OutputType[T,G]) - (implicit - ev: OutputType[T,G] <:< AbstractTypedColumn[T, G] - ): OutputType[T, Option[G]] = { - u(self.asInstanceOf[ThisType[T, X]]).asInstanceOf[OutputType[T, Option[G]]] - } - } - - /** Makes it easier to work with Optional columns. It returns an instance of `Mapper[X]` - * where `X` is type of the unwrapped Optional. E.g., in the case of `Option[Long]`, - * `X` is of type Long. - * - * {{{ - * val x: TypedColumn[Option[Int]] = _ - * x.opt.map(_*2) - * }}} - * */ - def opt[X](implicit x: U <:< Option[X]): Mapper[X] = new Mapper[X] {} - - /** Fall back to an untyped Column */ - def untyped: Column = new Column(expr) - - private def equalsTo[TT, W](other: ThisType[TT, U])(implicit w: With.Aux[T, TT, W]): ThisType[W, Boolean] = typed { - if (uencoder.nullable) EqualNullSafe(self.expr, other.expr) - else EqualTo(self.expr, other.expr) - } - - /** Creates a typed column of either TypedColumn or TypedAggregate from an expression. */ - protected def typed[W, U1: TypedEncoder](e: Expression): ThisType[W, U1] = - typed(new Column(e)) - - /** Creates a typed column of either TypedColumn or TypedAggregate. */ - def typed[W, U1: TypedEncoder](c: Column): ThisType[W, U1] - - /** Creates a typed column of either TypedColumn or TypedAggregate. */ - def lit[U1: TypedEncoder](c: U1): ThisType[T, U1] - - /** Equality test. - * {{{ - * df.filter( df.col('a) === 1 ) - * }}} - * - * apache/spark - */ - def ===(u: U): ThisType[T, Boolean] = - equalsTo(lit(u)) - - /** Equality test. - * {{{ - * df.filter( df.col('a) === df.col('b) ) - * }}} - * - * apache/spark - */ - def ===[TT, W](other: ThisType[TT, U])(implicit w: With.Aux[T, TT, W]): ThisType[W, Boolean] = - equalsTo(other) - - /** Inequality test. - * {{{ - * df.filter( df.col('a) =!= df.col('b) ) - * }}} - * - * apache/spark - */ - def =!=[TT, W](other: ThisType[TT, U])(implicit w: With.Aux[T, TT, W]): ThisType[W, Boolean] = - typed(Not(equalsTo(other).expr)) - - /** Inequality test. - * {{{ - * df.filter( df.col('a) =!= "a" ) - * }}} - * - * apache/spark - */ - def =!=(u: U): ThisType[T, Boolean] = - typed(Not(equalsTo(lit(u)).expr)) - - /** True if the current expression is an Option and it's None. - * - * apache/spark - */ - def isNone(implicit i0: U <:< Option[_]): ThisType[T, Boolean] = - equalsTo[T, T](lit[U](None.asInstanceOf[U])) - - /** True if the current expression is an Option and it's not None. - * - * apache/spark - */ - def isNotNone(implicit i0: U <:< Option[_]): ThisType[T, Boolean] = - typed(Not(equalsTo(lit(None.asInstanceOf[U])).expr)) - - /** True if the current expression is a fractional number and is not NaN. - * - * apache/spark - */ - def isNaN(implicit n: CatalystNaN[U]): ThisType[T, Boolean] = - typed(self.untyped.isNaN) - - /** Convert an Optional column by providing a default value - * {{{ - * df( df('opt).getOrElse(df('defaultValue)) ) - * }}} - */ - def getOrElse[TT, W, Out](default: ThisType[TT, Out])(implicit i0: U =:= Option[Out], i1: With.Aux[T, TT, W]): ThisType[W, Out] = - typed(Coalesce(Seq(expr, default.expr)))(default.uencoder) - - /** Convert an Optional column by providing a default value - * {{{ - * df( df('opt).getOrElse(defaultConstant) ) - * }}} - */ - def getOrElse[Out: TypedEncoder](default: Out)(implicit i0: U =:= Option[Out]): ThisType[T, Out] = - getOrElse(lit[Out](default)) - - /** Sum of this expression and another expression. - * {{{ - * // The following selects the sum of a person's height and weight. - * people.select( people.col('height) plus people.col('weight) ) - * }}} - * - * apache/spark - */ - def plus[TT, W](other: ThisType[TT, U])(implicit n: CatalystNumeric[U], w: With.Aux[T, TT, W]): ThisType[W, U] = - typed(self.untyped.plus(other.untyped)) - - /** Sum of this expression and another expression. - * {{{ - * // The following selects the sum of a person's height and weight. - * people.select( people.col('height) + people.col('weight) ) - * }}} - * - * apache/spark - */ - def +[TT, W](other: ThisType[TT, U])(implicit n: CatalystNumeric[U], w: With.Aux[T, TT, W]): ThisType[W, U] = - plus(other) - - /** Sum of this expression (column) with a constant. - * {{{ - * // The following selects the sum of a person's height and weight. - * people.select( people('height) + 2 ) - * }}} - * - * @param u a constant of the same type - * apache/spark - */ - def +(u: U)(implicit n: CatalystNumeric[U]): ThisType[T, U] = - typed(self.untyped.plus(u)) - - /** - * Inversion of boolean expression, i.e. NOT. - * {{{ - * // Select rows that are not active (isActive === false) - * df.filter( !df('isActive) ) - * }}} - * - * apache/spark - */ - def unary_!(implicit i0: U <:< Boolean): ThisType[T, Boolean] = - typed(!untyped) - - /** Unary minus, i.e. negate the expression. - * {{{ - * // Select the amount column and negates all values. - * df.select( -df('amount) ) - * }}} - * - * apache/spark - */ - def unary_-(implicit n: CatalystNumeric[U]): ThisType[T, U] = - typed(-self.untyped) - - /** Subtraction. Subtract the other expression from this expression. - * {{{ - * // The following selects the difference between people's height and their weight. - * people.select( people.col('height) minus people.col('weight) ) - * }}} - * - * apache/spark - */ - def minus[TT, W](other: ThisType[TT, U])(implicit n: CatalystNumeric[U], w: With.Aux[T, TT, W]): ThisType[W, U] = - typed(self.untyped.minus(other.untyped)) - - /** Subtraction. Subtract the other expression from this expression. - * {{{ - * // The following selects the difference between people's height and their weight. - * people.select( people.col('height) - people.col('weight) ) - * }}} - * - * apache/spark - */ - def -[TT, W](other: ThisType[TT, U])(implicit n: CatalystNumeric[U], w: With.Aux[T, TT, W]): ThisType[W, U] = - minus(other) - - /** Subtraction. Subtract the other expression from this expression. - * {{{ - * // The following selects the difference between people's height and their weight. - * people.select( people('height) - 1 ) - * }}} - * - * @param u a constant of the same type - * apache/spark - */ - def -(u: U)(implicit n: CatalystNumeric[U]): ThisType[T, U] = - typed(self.untyped.minus(u)) - - /** Multiplication of this expression and another expression. - * {{{ - * // The following multiplies a person's height by their weight. - * people.select( people.col('height) multiply people.col('weight) ) - * }}} - * - * apache/spark - */ - def multiply[TT, W] - (other: ThisType[TT, U]) - (implicit - n: CatalystNumeric[U], - w: With.Aux[T, TT, W], - t: ClassTag[U] - ): ThisType[W, U] = typed { - if (t.runtimeClass == BigDecimal(0).getClass) { - // That's apparently the only way to get sound multiplication. - // See https://issues.apache.org/jira/browse/SPARK-22036 - val dt = DecimalType(20, 14) - self.untyped.cast(dt).multiply(other.untyped.cast(dt)) - } else { - self.untyped.multiply(other.untyped) - } - } - - /** Multiplication of this expression and another expression. - * {{{ - * // The following multiplies a person's height by their weight. - * people.select( people.col('height) * people.col('weight) ) - * }}} - * - * apache/spark - */ - def *[TT, W](other: ThisType[TT, U])(implicit n: CatalystNumeric[U], w: With.Aux[T, TT, W], t: ClassTag[U]): ThisType[W, U] = - multiply(other) - - /** Multiplication of this expression a constant. - * {{{ - * // The following multiplies a person's height by their weight. - * people.select( people.col('height) * people.col('weight) ) - * }}} - * - * apache/spark - */ - def *(u: U)(implicit n: CatalystNumeric[U]): ThisType[T, U] = - typed(self.untyped.multiply(u)) - - /** Modulo (a.k.a. remainder) expression. - * - * apache/spark - */ - def mod[Out: TypedEncoder, TT, W](other: ThisType[TT, U])(implicit n: CatalystNumeric[U], w: With.Aux[T, TT, W]): ThisType[W, Out] = - typed(self.untyped.mod(other.untyped)) - - /** Modulo (a.k.a. remainder) expression. - * - * apache/spark - */ - def %[TT, W](other: ThisType[TT, U])(implicit n: CatalystNumeric[U], w: With.Aux[T, TT, W]): ThisType[W, U] = - mod(other) - - /** Modulo (a.k.a. remainder) expression. - * - * apache/spark - */ - def %(u: U)(implicit n: CatalystNumeric[U]): ThisType[T, U] = - typed(self.untyped.mod(u)) - - /** Division this expression by another expression. - * {{{ - * // The following divides a person's height by their weight. - * people.select( people('height) / people('weight) ) - * }}} - * - * @param other another column of the same type - * apache/spark - */ - def divide[Out: TypedEncoder, TT, W](other: ThisType[TT, U])(implicit n: CatalystDivisible[U, Out], w: With.Aux[T, TT, W]): ThisType[W, Out] = - typed(self.untyped.divide(other.untyped)) - - /** Division this expression by another expression. - * {{{ - * // The following divides a person's height by their weight. - * people.select( people('height) / people('weight) ) - * }}} - * - * @param other another column of the same type - * apache/spark - */ - def /[Out, TT, W](other: ThisType[TT, U])(implicit n: CatalystDivisible[U, Out], e: TypedEncoder[Out], w: With.Aux[T, TT, W]): ThisType[W, Out] = - divide(other) - - /** Division this expression by another expression. - * {{{ - * // The following divides a person's height by their weight. - * people.select( people('height) / 2 ) - * }}} - * - * @param u a constant of the same type - * apache/spark - */ - def /(u: U)(implicit n: CatalystNumeric[U]): ThisType[T, Double] = - typed(self.untyped.divide(u)) - - /** Returns a descending ordering used in sorting - * - * apache/spark - */ - def desc(implicit catalystOrdered: CatalystOrdered[U]): SortedTypedColumn[T, U] = - new SortedTypedColumn[T, U](untyped.desc) - - /** Returns an ascending ordering used in sorting - * - * apache/spark - */ - def asc(implicit catalystOrdered: CatalystOrdered[U]): SortedTypedColumn[T, U] = - new SortedTypedColumn[T, U](untyped.asc) - - /** Bitwise AND this expression and another expression. - * {{{ - * df.select(df.col('colA) bitwiseAND (df.col('colB))) - * }}} - * - * @param u a constant of the same type - * apache/spark - */ - def bitwiseAND(u: U)(implicit n: CatalystBitwise[U]): ThisType[T, U] = - typed(self.untyped.bitwiseAND(u)) - - /** Bitwise AND this expression and another expression. - * {{{ - * df.select(df.col('colA) bitwiseAND (df.col('colB))) - * }}} - * - * @param u a constant of the same type - * apache/spark - */ - def bitwiseAND[TT, W](other: ThisType[TT, U])(implicit n: CatalystBitwise[U], w: With.Aux[T, TT, W]): ThisType[W, U] = - typed(self.untyped.bitwiseAND(other.untyped)) - - /** Bitwise AND this expression and another expression (of same type). - * {{{ - * df.select(df.col('colA).cast[Int] & -1) - * }}} - * - * @param u a constant of the same type - * apache/spark - */ - def &(u: U)(implicit n: CatalystBitwise[U]): ThisType[T, U] = - bitwiseAND(u) - - /** Bitwise AND this expression and another expression. - * {{{ - * df.select(df.col('colA) & (df.col('colB))) - * }}} - * - * @param other a constant of the same type - * apache/spark - */ - def &[TT, W](other: ThisType[TT, U])(implicit n: CatalystBitwise[U], w: With.Aux[T, TT, W]): ThisType[W, U] = - bitwiseAND(other) - - /** Bitwise OR this expression and another expression. - * {{{ - * df.select(df.col('colA) bitwiseOR (df.col('colB))) - * }}} - * - * @param u a constant of the same type - * apache/spark - */ - def bitwiseOR(u: U)(implicit n: CatalystBitwise[U]): ThisType[T, U] = - typed(self.untyped.bitwiseOR(u)) - - /** Bitwise OR this expression and another expression. - * {{{ - * df.select(df.col('colA) bitwiseOR (df.col('colB))) - * }}} - * - * @param other a constant of the same type - * apache/spark - */ - def bitwiseOR[TT, W](other: ThisType[TT, U])(implicit n: CatalystBitwise[U], w: With.Aux[T, TT, W]): ThisType[W, U] = - typed(self.untyped.bitwiseOR(other.untyped)) - - /** Bitwise OR this expression and another expression (of same type). - * {{{ - * df.select(df.col('colA).cast[Long] | 1L) - * }}} - * - * @param u a constant of the same type - * apache/spark - */ - def |(u: U)(implicit n: CatalystBitwise[U]): ThisType[T, U] = - bitwiseOR(u) - - /** Bitwise OR this expression and another expression. - * {{{ - * df.select(df.col('colA) | (df.col('colB))) - * }}} - * - * @param other a constant of the same type - * apache/spark - */ - def |[TT, W](other: ThisType[TT, U])(implicit n: CatalystBitwise[U], w: With.Aux[T, TT, W]): ThisType[W, U] = - bitwiseOR(other) - - /** Bitwise XOR this expression and another expression. - * {{{ - * df.select(df.col('colA) bitwiseXOR (df.col('colB))) - * }}} - * - * @param u a constant of the same type - * apache/spark - */ - def bitwiseXOR(u: U)(implicit n: CatalystBitwise[U]): ThisType[T, U] = - typed(self.untyped.bitwiseXOR(u)) - - /** Bitwise XOR this expression and another expression. - * {{{ - * df.select(df.col('colA) bitwiseXOR (df.col('colB))) - * }}} - * - * @param other a constant of the same type - * apache/spark - */ - def bitwiseXOR[TT, W](other: ThisType[TT, U])(implicit n: CatalystBitwise[U], w: With.Aux[T, TT, W]): ThisType[W, U] = - typed(self.untyped.bitwiseXOR(other.untyped)) - - /** Bitwise XOR this expression and another expression (of same type). - * {{{ - * df.select(df.col('colA).cast[Long] ^ 1L) - * }}} - * - * @param u a constant of the same type - * apache/spark - */ - def ^(u: U)(implicit n: CatalystBitwise[U]): ThisType[T, U] = - bitwiseXOR(u) - - /** Bitwise XOR this expression and another expression. - * {{{ - * df.select(df.col('colA) ^ (df.col('colB))) - * }}} - * - * @param other a constant of the same type - * apache/spark - */ - def ^[TT, W](other: ThisType[TT, U])(implicit n: CatalystBitwise[U], w: With.Aux[T, TT, W]): ThisType[W, U] = - bitwiseXOR(other) - - /** Casts the column to a different type. - * {{{ - * df.select(df('a).cast[Int]) - * }}} - */ - def cast[A: TypedEncoder](implicit c: CatalystCast[U, A]): ThisType[T, A] = - typed(self.untyped.cast(TypedEncoder[A].catalystRepr)) - - /** - * An expression that returns a substring - * {{{ - * df.select(df('a).substr(0, 5)) - * }}} - * - * @param startPos starting position - * @param len length of the substring - */ - def substr(startPos: Int, len: Int)(implicit ev: U =:= String): ThisType[T, String] = - typed(self.untyped.substr(startPos, len)) - - /** - * An expression that returns a substring - * {{{ - * df.select(df('a).substr(df('b), df('c))) - * }}} - * - * @param startPos expression for the starting position - * @param len expression for the length of the substring - */ - def substr[TT1, TT2, W1, W2](startPos: ThisType[TT1, Int], len: ThisType[TT2, Int]) - (implicit - ev: U =:= String, - w1: With.Aux[T, TT1, W1], - w2: With.Aux[W1, TT2, W2]): ThisType[W2, String] = - typed(self.untyped.substr(startPos.untyped, len.untyped)) - - /** SQL like expression. Returns a boolean column based on a SQL LIKE match. - * {{{ - * val ds = TypedDataset.create(X2("foo", "bar") :: Nil) - * // true - * ds.select(ds('a).like("foo")) - * - * // Selected column has value "bar" - * ds.select(when(ds('a).like("f"), ds('a)).otherwise(ds('b)) - * }}} - * apache/spark - */ - def like(literal: String)(implicit ev: U =:= String): ThisType[T, Boolean] = - typed(self.untyped.like(literal)) - - /** SQL RLIKE expression (LIKE with Regex). Returns a boolean column based on a regex match. - * {{{ - * val ds = TypedDataset.create(X1("foo") :: Nil) - * // true - * ds.select(ds('a).rlike("foo")) - * - * // true - * ds.select(ds('a).rlike(".*)) - * }}} - * apache/spark - */ - def rlike(literal: String)(implicit ev: U =:= String): ThisType[T, Boolean] = - typed(self.untyped.rlike(literal)) - - /** String contains another string literal. - * {{{ - * df.filter ( df.col('a).contains("foo") ) - * }}} - * - * @param other a string that is being tested against. - * apache/spark - */ - def contains(other: String)(implicit ev: U =:= String): ThisType[T, Boolean] = - typed(self.untyped.contains(other)) - - /** String contains. - * {{{ - * df.filter ( df.col('a).contains(df.col('b) ) - * }}} - * - * @param other a column which values is used as a string that is being tested against. - * apache/spark - */ - def contains[TT, W](other: ThisType[TT, U])(implicit ev: U =:= String, w: With.Aux[T, TT, W]): ThisType[W, Boolean] = - typed(self.untyped.contains(other.untyped)) - - /** String starts with another string literal. - * {{{ - * df.filter ( df.col('a).startsWith("foo") - * }}} - * - * @param other a prefix that is being tested against. - * apache/spark - */ - def startsWith(other: String)(implicit ev: U =:= String): ThisType[T, Boolean] = - typed(self.untyped.startsWith(other)) - - /** String starts with. - * {{{ - * df.filter ( df.col('a).startsWith(df.col('b)) - * }}} - * - * @param other a column which values is used as a prefix that is being tested against. - * apache/spark - */ - def startsWith[TT, W](other: ThisType[TT, U])(implicit ev: U =:= String, w: With.Aux[T, TT, W]): ThisType[W, Boolean] = - typed(self.untyped.startsWith(other.untyped)) - - /** String ends with another string literal. - * {{{ - * df.filter ( df.col('a).endsWith("foo") - * }}} - * - * @param other a suffix that is being tested against. - * apache/spark - */ - def endsWith(other: String)(implicit ev: U =:= String): ThisType[T, Boolean] = - typed(self.untyped.endsWith(other)) - - /** String ends with. - * {{{ - * df.filter ( df.col('a).endsWith(df.col('b)) - * }}} - * - * @param other a column which values is used as a suffix that is being tested against. - * apache/spark - */ - def endsWith[TT, W](other: ThisType[TT, U])(implicit ev: U =:= String, w: With.Aux[T, TT, W]): ThisType[W, Boolean] = - typed(self.untyped.endsWith(other.untyped)) - - /** Boolean AND. - * {{{ - * df.filter ( (df.col('a) === 1).and(df.col('b) > 5) ) - * }}} - */ - def and[TT, W](other: ThisType[TT, Boolean])(implicit w: With.Aux[T, TT, W]): ThisType[W, Boolean] = - typed(self.untyped.and(other.untyped)) - - /** Boolean AND. - * {{{ - * df.filter ( df.col('a) === 1 && df.col('b) > 5) - * }}} - */ - def && [TT, W](other: ThisType[TT, Boolean])(implicit w: With.Aux[T, TT, W]): ThisType[W, Boolean] = - and(other) - - /** Boolean OR. - * {{{ - * df.filter ( (df.col('a) === 1).or(df.col('b) > 5) ) - * }}} - */ - def or[TT, W](other: ThisType[TT, Boolean])(implicit w: With.Aux[T, TT, W]): ThisType[W, Boolean] = - typed(self.untyped.or(other.untyped)) - - /** Boolean OR. - * {{{ - * df.filter ( df.col('a) === 1 || df.col('b) > 5) - * }}} - */ - def || [TT, W](other: ThisType[TT, Boolean])(implicit w: With.Aux[T, TT, W]): ThisType[W, Boolean] = - or(other) - - /** Less than. - * {{{ - * // The following selects people younger than the maxAge column. - * df.select( df('age) < df('maxAge) ) - * }}} - * - * @param other another column of the same type - * apache/spark - */ - def <[TT, W](other: ThisType[TT, U])(implicit i0: CatalystOrdered[U], w: With.Aux[T, TT, W]): ThisType[W, Boolean] = - typed(self.untyped < other.untyped) - - /** Less than or equal to. - * {{{ - * // The following selects people younger or equal than the maxAge column. - * df.select( df('age) <= df('maxAge) - * }}} - * - * @param other another column of the same type - * apache/spark - */ - def <=[TT, W](other: ThisType[TT, U])(implicit i0: CatalystOrdered[U], w: With.Aux[T, TT, W]): ThisType[W, Boolean] = - typed(self.untyped <= other.untyped) - - /** Greater than. - * {{{ - * // The following selects people older than the maxAge column. - * df.select( df('age) > df('maxAge) ) - * }}} - * - * @param other another column of the same type - * apache/spark - */ - def >[TT, W](other: ThisType[TT, U])(implicit i0: CatalystOrdered[U], w: With.Aux[T, TT, W]): ThisType[W, Boolean] = - typed(self.untyped > other.untyped) - - /** Greater than or equal. - * {{{ - * // The following selects people older or equal than the maxAge column. - * df.select( df('age) >= df('maxAge) ) - * }}} - * - * @param other another column of the same type - * apache/spark - */ - def >=[TT, W](other: ThisType[TT, U])(implicit i0: CatalystOrdered[U], w: With.Aux[T, TT, W]): ThisType[W, Boolean] = - typed(self.untyped >= other.untyped) - - /** Less than. - * {{{ - * // The following selects people younger than 21. - * df.select( df('age) < 21 ) - * }}} - * - * @param u a constant of the same type - * apache/spark - */ - def <(u: U)(implicit i0: CatalystOrdered[U]): ThisType[T, Boolean] = - typed(self.untyped < lit(u)(self.uencoder).untyped) - - /** Less than or equal to. - * {{{ - * // The following selects people younger than 22. - * df.select( df('age) <= 2 ) - * }}} - * - * @param u a constant of the same type - * apache/spark - */ - def <=(u: U)(implicit i0: CatalystOrdered[U]): ThisType[T, Boolean] = - typed(self.untyped <= lit(u)(self.uencoder).untyped) - - /** Greater than. - * {{{ - * // The following selects people older than 21. - * df.select( df('age) > 21 ) - * }}} - * - * @param u another column of the same type - * apache/spark - */ - def >(u: U)(implicit i0: CatalystOrdered[U]): ThisType[T, Boolean] = - typed(self.untyped > lit(u)(self.uencoder).untyped) - - /** Greater than or equal. - * {{{ - * // The following selects people older than 20. - * df.select( df('age) >= 21 ) - * }}} - * - * @param u another column of the same type - * apache/spark - */ - def >=(u: U)(implicit i0: CatalystOrdered[U]): ThisType[T, Boolean] = - typed(self.untyped >= lit(u)(self.uencoder).untyped) - - /** - * Returns true if the value of this column is contained in of the arguments. - * {{{ - * // The following selects people with age 15, 20, or 30. - * df.select( df('age).isin(15, 20, 30) ) - * }}} - * - * @param values are constants of the same type - * apache/spark - */ - def isin(values: U*)(implicit e: CatalystIsin[U]): ThisType[T, Boolean] = - typed(self.untyped.isin(values:_*)) - - /** - * True if the current column is between the lower bound and upper bound, inclusive. - * - * @param lowerBound a constant of the same type - * @param upperBound a constant of the same type - * apache/spark - */ - def between(lowerBound: U, upperBound: U)(implicit i0: CatalystOrdered[U]): ThisType[T, Boolean] = - typed(self.untyped.between(lit(lowerBound)(self.uencoder).untyped, lit(upperBound)(self.uencoder).untyped)) - - /** - * True if the current column is between the lower bound and upper bound, inclusive. - * - * @param lowerBound another column of the same type - * @param upperBound another column of the same type - * apache/spark - */ - def between[TT1, TT2, W1, W2](lowerBound: ThisType[TT1, U], upperBound: ThisType[TT2, U]) - (implicit - i0: CatalystOrdered[U], - w0: With.Aux[T, TT1, W1], - w1: With.Aux[TT2, W1, W2] - ): ThisType[W2, Boolean] = - typed(self.untyped.between(lowerBound.untyped, upperBound.untyped)) -} - - -sealed class SortedTypedColumn[T, U](val expr: Expression)( - implicit - val uencoder: TypedEncoder[U] -) extends UntypedExpression[T] { - - def this(column: Column)(implicit e: TypedEncoder[U]) { - this(FramelessInternals.expr(column)) - } - - def untyped: Column = new Column(expr) -} - -object SortedTypedColumn { - implicit def defaultAscending[T, U : CatalystOrdered](typedColumn: TypedColumn[T, U]): SortedTypedColumn[T, U] = - new SortedTypedColumn[T, U](typedColumn.untyped.asc)(typedColumn.uencoder) - - object defaultAscendingPoly extends Poly1 { - implicit def caseTypedColumn[T, U : CatalystOrdered] = at[TypedColumn[T, U]](c => defaultAscending(c)) - implicit def caseTypeSortedColumn[T, U] = at[SortedTypedColumn[T, U]](identity) - } - } - - -object TypedColumn { - /** Evidence that type `T` has column `K` with type `V`. */ - @implicitNotFound(msg = "No column ${K} of type ${V} in ${T}") - trait Exists[T, K, V] - - @implicitNotFound(msg = "No columns ${K} of type ${V} in ${T}") - trait ExistsMany[T, K <: HList, V] - - object ExistsMany { - implicit def deriveCons[T, KH, KT <: HList, V0, V1] - (implicit - head: Exists[T, KH, V0], - tail: ExistsMany[V0, KT, V1] - ): ExistsMany[T, KH :: KT, V1] = - new ExistsMany[T, KH :: KT, V1] {} - - implicit def deriveHNil[T, K, V](implicit head: Exists[T, K, V]): ExistsMany[T, K :: HNil, V] = - new ExistsMany[T, K :: HNil, V] {} - } - - object Exists { - def apply[T, V](column: Witness)(implicit e: Exists[T, column.T, V]): Exists[T, column.T, V] = e - - implicit def deriveRecord[T, H <: HList, K, V] - (implicit - i0: LabelledGeneric.Aux[T, H], - i1: Selector.Aux[H, K, V] - ): Exists[T, K, V] = new Exists[T, K, V] {} - } -} - -/** Compute the intersection of two types: - * - * - With[A, A] = A - * - With[A, B] = A with B (when A != B) - * - * This type function is needed to prevent IDEs from infering large types - * with shape `A with A with ... with A`. These types could be confusing for - * both end users and IDE's type checkers. - */ -trait With[A, B] { type Out } - -trait LowPrioWith { - type Aux[A, B, W] = With[A, B] { type Out = W } - protected[this] val theInstance = new With[Any, Any] {} - protected[this] def of[A, B, W]: With[A, B] { type Out = W } = theInstance.asInstanceOf[Aux[A, B, W]] - implicit def identity[T]: Aux[T, T, T] = of[T, T, T] -} - -object With extends LowPrioWith { - implicit def combine[A, B]: Aux[A, B, A with B] = of[A, B, A with B] -} diff --git a/dataset/src/main/scala/frameless/TypedDataset.scala b/dataset/src/main/scala/frameless/TypedDataset.scala deleted file mode 100644 index 3f8df6ee1..000000000 --- a/dataset/src/main/scala/frameless/TypedDataset.scala +++ /dev/null @@ -1,1295 +0,0 @@ -package frameless - -import java.util - -import frameless.functions.CatalystExplodableCollection -import frameless.ops._ -import org.apache.spark.rdd.RDD -import org.apache.spark.sql._ -import org.apache.spark.sql.catalyst.expressions.{Attribute, AttributeReference, Literal} -import org.apache.spark.sql.catalyst.plans.logical.{Join, JoinHint} -import org.apache.spark.sql.catalyst.plans.Inner -import org.apache.spark.sql.types.StructType -import shapeless._ -import shapeless.labelled.FieldType -import shapeless.ops.hlist.{Diff, IsHCons, Mapper, Prepend, ToTraversable, Tupler} -import shapeless.ops.record.{Keys, Modifier, Remover, Values} - -/** [[TypedDataset]] is a safer interface for working with `Dataset`. - * - * NOTE: Prefer `TypedDataset.create` over `new TypedDataset` unless you - * know what you are doing. - * - * Documentation marked "apache/spark" is thanks to apache/spark Contributors - * at https://github.com/apache/spark, licensed under Apache v2.0 available at - * http://www.apache.org/licenses/LICENSE-2.0 - */ -class TypedDataset[T] protected[frameless](val dataset: Dataset[T])(implicit val encoder: TypedEncoder[T]) - extends TypedDatasetForwarded[T] { self => - - private implicit val spark: SparkSession = dataset.sparkSession - - /** Aggregates on the entire Dataset without groups. - * - * apache/spark - */ - def agg[A](ca: TypedAggregate[T, A]): TypedDataset[A] = { - implicit val ea = ca.uencoder - val tuple1: TypedDataset[Tuple1[A]] = aggMany(ca) - - // now we need to unpack `Tuple1[A]` to `A` - TypedEncoder[A].catalystRepr match { - case StructType(_) => - // if column is struct, we use all its fields - val df = tuple1 - .dataset - .selectExpr("_1.*") - .as[A](TypedExpressionEncoder[A]) - - TypedDataset.create(df) - case other => - // for primitive types `Tuple1[A]` has the same schema as `A` - TypedDataset.create(tuple1.dataset.as[A](TypedExpressionEncoder[A])) - } - } - - /** Aggregates on the entire Dataset without groups. - * - * apache/spark - */ - def agg[A, B]( - ca: TypedAggregate[T, A], - cb: TypedAggregate[T, B] - ): TypedDataset[(A, B)] = { - implicit val (ea, eb) = (ca.uencoder, cb.uencoder) - aggMany(ca, cb) - } - - /** Aggregates on the entire Dataset without groups. - * - * apache/spark - */ - def agg[A, B, C]( - ca: TypedAggregate[T, A], - cb: TypedAggregate[T, B], - cc: TypedAggregate[T, C] - ): TypedDataset[(A, B, C)] = { - implicit val (ea, eb, ec) = (ca.uencoder, cb.uencoder, cc.uencoder) - aggMany(ca, cb, cc) - } - - /** Aggregates on the entire Dataset without groups. - * - * apache/spark - */ - def agg[A, B, C, D]( - ca: TypedAggregate[T, A], - cb: TypedAggregate[T, B], - cc: TypedAggregate[T, C], - cd: TypedAggregate[T, D] - ): TypedDataset[(A, B, C, D)] = { - implicit val (ea, eb, ec, ed) = (ca.uencoder, cb.uencoder, cc.uencoder, cd.uencoder) - aggMany(ca, cb, cc, cd) - } - - /** Aggregates on the entire Dataset without groups. - * - * apache/spark - */ - object aggMany extends ProductArgs { - def applyProduct[U <: HList, Out0 <: HList, Out](columns: U) - (implicit - i0: AggregateTypes.Aux[T, U, Out0], - i1: ToTraversable.Aux[U, List, UntypedExpression[T]], - i2: Tupler.Aux[Out0, Out], - i3: TypedEncoder[Out] - ): TypedDataset[Out] = { - - val underlyingColumns = columns.toList[UntypedExpression[T]] - val cols: Seq[Column] = for { - (c, i) <- columns.toList[UntypedExpression[T]].zipWithIndex - } yield new Column(c.expr).as(s"_${i+1}") - - // Workaround to SPARK-20346. One alternative is to allow the result to be Vector(null) for empty DataFrames. - // Another one would be to return an Option. - val filterStr = ( - for { - (c, i) <- underlyingColumns.zipWithIndex - if !c.uencoder.nullable - } yield s"_${i+1} is not null" - ).mkString(" or ") - - val selected = dataset.toDF().agg(cols.head, cols.tail:_*).as[Out](TypedExpressionEncoder[Out]) - TypedDataset.create[Out](if (filterStr.isEmpty) selected else selected.filter(filterStr)) - } - } - - /** Returns a new [[TypedDataset]] where each record has been mapped on to the specified type. */ - def as[U]()(implicit as: As[T, U]): TypedDataset[U] = { - implicit val uencoder = as.encoder - TypedDataset.create(dataset.as[U](TypedExpressionEncoder[U])) - } - - /** Returns a checkpointed version of this [[TypedDataset]]. Checkpointing can be used to truncate the - * logical plan of this Dataset, which is especially useful in iterative algorithms where the - * plan may grow exponentially. It will be saved to files inside the checkpoint - * directory set with `SparkContext#setCheckpointDir`. - * - * Differs from `Dataset#checkpoint` by wrapping its result into an effect-suspending `F[_]`. - * - * apache/spark - */ - def checkpoint[F[_]](eager: Boolean)(implicit F: SparkDelay[F]): F[TypedDataset[T]] = - F.delay(TypedDataset.create[T](dataset.checkpoint(eager))) - - /** Returns a new [[TypedDataset]] where each record has been mapped on to the specified type. - * Unlike `as` the projection U may include a subset of the columns of T and the column names and types must agree. - * - * {{{ - * case class Foo(i: Int, j: String) - * case class Bar(j: String) - * - * val t: TypedDataset[Foo] = ... - * val b: TypedDataset[Bar] = t.project[Bar] - * - * case class BarErr(e: String) - * // The following does not compile because `Foo` doesn't have a field with name `e` - * val e: TypedDataset[BarErr] = t.project[BarErr] - * }}} - */ - def project[U](implicit projector: SmartProject[T,U]): TypedDataset[U] = projector.apply(this) - - /** Returns a new [[TypedDataset]] that contains the elements of both this and the `other` [[TypedDataset]] - * combined. - * - * Note that, this function is not a typical set union operation, in that it does not eliminate - * duplicate items. As such, it is analogous to `UNION ALL` in SQL. - * - * Differs from `Dataset#union` by aligning fields if possible. - * It will not compile if `Datasets` have not compatible schema. - * - * Example: - * {{{ - * case class Foo(x: Int, y: Long) - * case class Bar(y: Long, x: Int) - * case class Faz(x: Int, y: Int, z: Int) - * - * foo: TypedDataset[Foo] = ... - * bar: TypedDataset[Bar] = ... - * faz: TypedDataset[Faz] = ... - * - * foo union bar: TypedDataset[Foo] - * foo union faz: TypedDataset[Foo] - * // won't compile, you need to reverse order, you can't project from less fields to more - * faz union foo - * - * }}} - * - * apache/spark - */ - def union[U: TypedEncoder](other: TypedDataset[U])(implicit projector: SmartProject[U, T]): TypedDataset[T] = - TypedDataset.create(dataset.union(other.project[T].dataset)) - - /** Returns a new [[TypedDataset]] that contains the elements of both this and the `other` [[TypedDataset]] - * combined. - * - * Note that, this function is not a typical set union operation, in that it does not eliminate - * duplicate items. As such, it is analogous to `UNION ALL` in SQL. - * - * apache/spark - */ - def union(other: TypedDataset[T]): TypedDataset[T] = { - TypedDataset.create(dataset.union(other.dataset)) - } - - /** Returns the number of elements in the [[TypedDataset]]. - * - * Differs from `Dataset#count` by wrapping its result into an effect-suspending `F[_]`. - */ - def count[F[_]]()(implicit F: SparkDelay[F]): F[Long] = - F.delay(dataset.count) - - /** Returns `TypedColumn` of type `A` given its name. - * - * {{{ - * tf('id) - * }}} - * - * It is statically checked that column with such name exists and has type `A`. - */ - def apply[A](column: Witness.Lt[Symbol]) - (implicit - i0: TypedColumn.Exists[T, column.T, A], - i1: TypedEncoder[A] - ): TypedColumn[T, A] = col(column) - - /** Returns `TypedColumn` of type `A` given its name. - * - * {{{ - * tf.col('id) - * }}} - * - * It is statically checked that column with such name exists and has type `A`. - */ - def col[A](column: Witness.Lt[Symbol]) - (implicit - i0: TypedColumn.Exists[T, column.T, A], - i1: TypedEncoder[A] - ): TypedColumn[T, A] = - new TypedColumn[T, A](dataset(column.value.name).as[A](TypedExpressionEncoder[A])) - - /** Projects the entire TypedDataset[T] into a single column of type TypedColumn[T,T] - * {{{ - * ts: TypedDataset[Foo] = ... - * ts.select(ts.asCol, ts.asCol): TypedDataset[(Foo,Foo)] - * }}} - */ - def asCol: TypedColumn[T, T] = { - val projectedColumn: Column = encoder.catalystRepr match { - case StructType(_) => - val allColumns: Array[Column] = dataset.columns.map(dataset.col) - org.apache.spark.sql.functions.struct(allColumns: _*) - case _ => - dataset.col(dataset.columns.head) - } - new TypedColumn[T,T](projectedColumn) - } - - object colMany extends SingletonProductArgs { - def applyProduct[U <: HList, Out](columns: U) - (implicit - i0: TypedColumn.ExistsMany[T, U, Out], - i1: TypedEncoder[Out], - i2: ToTraversable.Aux[U, List, Symbol] - ): TypedColumn[T, Out] = { - val names = columns.toList[Symbol].map(_.name) - val colExpr = FramelessInternals.resolveExpr(dataset, names) - new TypedColumn[T, Out](colExpr) - } - } - - /** Right hand side disambiguation of `col` for join expressions. - * To be used when writting self-joins, noop in other circumstances. - * - * Note: In vanilla Spark, disambiguation in self-joins is acheaved using - * String based aliases, which is obviously unsafe. - */ - def colRight[A](column: Witness.Lt[Symbol]) - (implicit - i0: TypedColumn.Exists[T, column.T, A], - i1: TypedEncoder[A] - ): TypedColumn[T, A] = - new TypedColumn[T, A](FramelessInternals.DisambiguateRight(col(column).expr)) - - /** Left hand side disambiguation of `col` for join expressions. - * To be used when writting self-joins, noop in other circumstances. - * - * Note: In vanilla Spark, disambiguation in self-joins is acheaved using - * String based aliases, which is obviously unsafe. - */ - def colLeft[A](column: Witness.Lt[Symbol]) - (implicit - i0: TypedColumn.Exists[T, column.T, A], - i1: TypedEncoder[A] - ): TypedColumn[T, A] = - new TypedColumn[T, A](FramelessInternals.DisambiguateLeft(col(column).expr)) - - /** Returns a `Seq` that contains all the elements in this [[TypedDataset]]. - * - * Running this operation requires moving all the data into the application's driver process, and - * doing so on a very large [[TypedDataset]] can crash the driver process with OutOfMemoryError. - * - * Differs from `Dataset#collect` by wrapping its result into an effect-suspending `F[_]`. - */ - def collect[F[_]]()(implicit F: SparkDelay[F]): F[Seq[T]] = - F.delay(dataset.collect()) - - /** Optionally returns the first element in this [[TypedDataset]]. - * - * Differs from `Dataset#first` by wrapping its result into an `Option` and an effect-suspending `F[_]`. - */ - def firstOption[F[_]]()(implicit F: SparkDelay[F]): F[Option[T]] = - F.delay { - try { - Option(dataset.first()) - } catch { - case e: NoSuchElementException => None - } - } - - /** Returns the first `num` elements of this [[TypedDataset]] as a `Seq`. - * - * Running take requires moving data into the application's driver process, and doing so with - * a very large `num` can crash the driver process with OutOfMemoryError. - * - * Differs from `Dataset#take` by wrapping its result into an effect-suspending `F[_]`. - * - * apache/spark - */ - def take[F[_]](num: Int)(implicit F: SparkDelay[F]): F[Seq[T]] = - F.delay(dataset.take(num)) - - /** Return an iterator that contains all rows in this [[TypedDataset]]. - * - * The iterator will consume as much memory as the largest partition in this [[TypedDataset]]. - * - * NOTE: this results in multiple Spark jobs, and if the input [[TypedDataset]] is the result - * of a wide transformation (e.g. join with different partitioners), to avoid - * recomputing the input [[TypedDataset]] should be cached first. - * - * Differs from `Dataset#toLocalIterator()` by wrapping its result into an effect-suspending `F[_]`. - * - * apache/spark - */ - def toLocalIterator[F[_]]()(implicit F: SparkDelay[F]): F[util.Iterator[T]] = - F.delay(dataset.toLocalIterator()) - - /** Alias for firstOption(). - */ - def headOption[F[_]]()(implicit F: SparkDelay[F]): F[Option[T]] = firstOption() - - /** Alias for take(). - */ - def head[F[_]](num: Int)(implicit F: SparkDelay[F]): F[Seq[T]] = take(num) - - // $COVERAGE-OFF$ - /** Alias for firstOption(). - */ - @deprecated("Method may throw exception. Use headOption or firstOption instead.", "0.5.0") - def head: T = dataset.head() - - /** Alias for firstOption(). - */ - @deprecated("Method may throw exception. Use headOption or firstOption instead.", "0.5.0") - def first: T = dataset.head() - // $COVERAGE-ONN$ - - /** Displays the content of this [[TypedDataset]] in a tabular form. Strings more than 20 characters - * will be truncated, and all cells will be aligned right. For example: - * {{{ - * year month AVG('Adj Close) MAX('Adj Close) - * 1980 12 0.503218 0.595103 - * 1981 01 0.523289 0.570307 - * 1982 02 0.436504 0.475256 - * 1983 03 0.410516 0.442194 - * 1984 04 0.450090 0.483521 - * }}} - * @param numRows Number of rows to show - * @param truncate Whether truncate long strings. If true, strings more than 20 characters will - * be truncated and all cells will be aligned right - * - * Differs from `Dataset#show` by wrapping its result into an effect-suspending `F[_]`. - * - * apache/spark - */ - def show[F[_]](numRows: Int = 20, truncate: Boolean = true)(implicit F: SparkDelay[F]): F[Unit] = - F.delay(dataset.show(numRows, truncate)) - - /** Returns a new [[frameless.TypedDataset]] that only contains elements where `column` is `true`. - * - * Differs from `TypedDatasetForward#filter` by taking a `TypedColumn[T, Boolean]` instead of a - * `T => Boolean`. Using a column expression instead of a regular function save one Spark → Scala - * deserialization which leads to better performance. - */ - def filter(column: TypedColumn[T, Boolean]): TypedDataset[T] = { - val filtered = dataset.toDF() - .filter(column.untyped) - .as[T](TypedExpressionEncoder[T]) - - TypedDataset.create[T](filtered) - } - - /** Runs `func` on each element of this [[TypedDataset]]. - * - * Differs from `Dataset#foreach` by wrapping its result into an effect-suspending `F[_]`. - */ - def foreach[F[_]](func: T => Unit)(implicit F: SparkDelay[F]): F[Unit] = - F.delay(dataset.foreach(func)) - - /** Runs `func` on each partition of this [[TypedDataset]]. - * - * Differs from `Dataset#foreachPartition` by wrapping its result into an effect-suspending `F[_]`. - */ - def foreachPartition[F[_]](func: Iterator[T] => Unit)(implicit F: SparkDelay[F]): F[Unit] = - F.delay(dataset.foreachPartition(func)) - - /** - * Create a multi-dimensional cube for the current [[TypedDataset]] using the specified column, - * so we can run aggregation on it. - * See [[frameless.functions.AggregateFunctions]] for all the available aggregate functions. - * - * Differs from `Dataset#cube` by wrapping values into `Option` instead of returning `null`. - * - * apache/spark - */ - def cube[K1]( - c1: TypedColumn[T, K1] - ): Cube1Ops[K1, T] = new Cube1Ops[K1, T](this, c1) - - /** - * Create a multi-dimensional cube for the current [[TypedDataset]] using the specified columns, - * so we can run aggregation on them. - * See [[frameless.functions.AggregateFunctions]] for all the available aggregate functions. - * - * Differs from `Dataset#cube` by wrapping values into `Option` instead of returning `null`. - * - * apache/spark - */ - def cube[K1, K2]( - c1: TypedColumn[T, K1], - c2: TypedColumn[T, K2] - ): Cube2Ops[K1, K2, T] = new Cube2Ops[K1, K2, T](this, c1, c2) - - /** - * Create a multi-dimensional cube for the current [[TypedDataset]] using the specified columns, - * so we can run aggregation on them. - * See [[frameless.functions.AggregateFunctions]] for all the available aggregate functions. - * - * {{{ - * case class MyClass(a: Int, b: Int, c: Int) - * val ds: TypedDataset[MyClass] - - * val cubeDataset: TypedDataset[(Option[A], Option[B], Long)] = - * ds.cubeMany(ds('a), ds('b)).agg(count[MyClass]()) - * - * // original dataset: - * a b c - * 10 20 1 - * 15 25 2 - * - * // after aggregation: - * _1 _2 _3 - * 15 null 1 - * 15 25 1 - * null null 2 - * null 25 1 - * null 20 1 - * 10 null 1 - * 10 20 1 - * - * }}} - * - * Differs from `Dataset#cube` by wrapping values into `Option` instead of returning `null`. - * - * apache/spark - */ - object cubeMany extends ProductArgs { - def applyProduct[TK <: HList, K <: HList, KT](groupedBy: TK) - (implicit - i0: ColumnTypes.Aux[T, TK, K], - i1: Tupler.Aux[K, KT], - i2: ToTraversable.Aux[TK, List, UntypedExpression[T]] - ): CubeManyOps[T, TK, K, KT] = new CubeManyOps[T, TK, K, KT](self, groupedBy) - } - - /** - * Groups the [[TypedDataset]] using the specified columns, so that we can run aggregation on them. - * See [[frameless.functions.AggregateFunctions]] for all the available aggregate functions. - * - * apache/spark - */ - def groupBy[K1]( - c1: TypedColumn[T, K1] - ): GroupedBy1Ops[K1, T] = new GroupedBy1Ops[K1, T](this, c1) - - /** - * Groups the [[TypedDataset]] using the specified columns, so that we can run aggregation on them. - * See [[frameless.functions.AggregateFunctions]] for all the available aggregate functions. - * - * apache/spark - */ - def groupBy[K1, K2]( - c1: TypedColumn[T, K1], - c2: TypedColumn[T, K2] - ): GroupedBy2Ops[K1, K2, T] = new GroupedBy2Ops[K1, K2, T](this, c1, c2) - - /** - * Groups the [[TypedDataset]] using the specified columns, so that we can run aggregation on them. - * See [[frameless.functions.AggregateFunctions]] for all the available aggregate functions. - * - * {{{ - * case class MyClass(a: Int, b: Int, c: Int) - * val ds: TypedDataset[MyClass] - * - * val cubeDataset: TypedDataset[(Option[A], Option[B], Long)] = - * ds.groupByMany(ds('a), ds('b)).agg(count[MyClass]()) - * - * // original dataset: - * a b c - * 10 20 1 - * 15 25 2 - * - * // after aggregation: - * _1 _2 _3 - * 10 20 1 - * 15 25 1 - * - * }}} - * - * apache/spark - */ - object groupByMany extends ProductArgs { - def applyProduct[TK <: HList, K <: HList, KT](groupedBy: TK) - (implicit - i0: ColumnTypes.Aux[T, TK, K], - i1: Tupler.Aux[K, KT], - i2: ToTraversable.Aux[TK, List, UntypedExpression[T]] - ): GroupedByManyOps[T, TK, K, KT] = new GroupedByManyOps[T, TK, K, KT](self, groupedBy) - } - - /** - * Create a multi-dimensional rollup for the current [[TypedDataset]] using the specified column, - * so we can run aggregation on it. - * See [[frameless.functions.AggregateFunctions]] for all the available aggregate functions. - * - * Differs from `Dataset#rollup` by wrapping values into `Option` instead of returning `null`. - * - * apache/spark - */ - def rollup[K1]( - c1: TypedColumn[T, K1] - ): Rollup1Ops[K1, T] = new Rollup1Ops[K1, T](this, c1) - - /** - * Create a multi-dimensional rollup for the current [[TypedDataset]] using the specified columns, - * so we can run aggregation on them. - * See [[frameless.functions.AggregateFunctions]] for all the available aggregate functions. - * - * Differs from `Dataset#rollup` by wrapping values into `Option` instead of returning `null`. - * - * apache/spark - */ - def rollup[K1, K2]( - c1: TypedColumn[T, K1], - c2: TypedColumn[T, K2] - ): Rollup2Ops[K1, K2, T] = new Rollup2Ops[K1, K2, T](this, c1, c2) - - /** - * Create a multi-dimensional rollup for the current [[TypedDataset]] using the specified columns, - * so we can run aggregation on them. - * See [[frameless.functions.AggregateFunctions]] for all the available aggregate functions. - * - * {{{ - * case class MyClass(a: Int, b: Int, c: Int) - * val ds: TypedDataset[MyClass] - * - * val cubeDataset: TypedDataset[(Option[A], Option[B], Long)] = - * ds.rollupMany(ds('a), ds('b)).agg(count[MyClass]()) - * - * // original dataset: - * a b c - * 10 20 1 - * 15 25 2 - * - * // after aggregation: - * _1 _2 _3 - * 15 null 1 - * 15 25 1 - * null null 2 - * 10 null 1 - * 10 20 1 - * - * }}} - * - * Differs from `Dataset#rollup` by wrapping values into `Option` instead of returning `null`. - * - * apache/spark - */ - object rollupMany extends ProductArgs { - def applyProduct[TK <: HList, K <: HList, KT](groupedBy: TK) - (implicit - i0: ColumnTypes.Aux[T, TK, K], - i1: Tupler.Aux[K, KT], - i2: ToTraversable.Aux[TK, List, UntypedExpression[T]] - ): RollupManyOps[T, TK, K, KT] = new RollupManyOps[T, TK, K, KT](self, groupedBy) - } - - /** Computes the cartesian project of `this` `Dataset` with the `other` `Dataset` */ - def joinCross[U](other: TypedDataset[U]) - (implicit e: TypedEncoder[(T, U)]): TypedDataset[(T, U)] = - new TypedDataset(self.dataset.joinWith(other.dataset, new Column(Literal(true)), "cross")) - - /** Computes the full outer join of `this` `Dataset` with the `other` `Dataset`, - * returning a `Tuple2` for each pair where condition evaluates to true. - */ - def joinFull[U](other: TypedDataset[U])(condition: TypedColumn[T with U, Boolean]) - (implicit e: TypedEncoder[(Option[T], Option[U])]): TypedDataset[(Option[T], Option[U])] = - new TypedDataset(self.dataset.joinWith(other.dataset, condition.untyped, "full") - .as[(Option[T], Option[U])](TypedExpressionEncoder[(Option[T], Option[U])])) - - /** Computes the inner join of `this` `Dataset` with the `other` `Dataset`, - * returning a `Tuple2` for each pair where condition evaluates to true. - */ - def joinInner[U](other: TypedDataset[U])(condition: TypedColumn[T with U, Boolean]) - (implicit e: TypedEncoder[(T, U)]): TypedDataset[(T, U)] = { - import FramelessInternals._ - val leftPlan = logicalPlan(dataset) - val rightPlan = logicalPlan(other.dataset) - val join = disambiguate(Join(leftPlan, rightPlan, Inner, Some(condition.expr), JoinHint.NONE)) - val joinedPlan = joinPlan(dataset, join, leftPlan, rightPlan) - val joinedDs = mkDataset(dataset.sqlContext, joinedPlan, TypedExpressionEncoder[(T, U)]) - TypedDataset.create[(T, U)](joinedDs) - } - - /** Computes the left outer join of `this` `Dataset` with the `other` `Dataset`, - * returning a `Tuple2` for each pair where condition evaluates to true. - */ - def joinLeft[U](other: TypedDataset[U])(condition: TypedColumn[T with U, Boolean]) - (implicit e: TypedEncoder[(T, Option[U])]): TypedDataset[(T, Option[U])] = - new TypedDataset(self.dataset.joinWith(other.dataset, condition.untyped, "left_outer") - .as[(T, Option[U])](TypedExpressionEncoder[(T, Option[U])])) - - /** Computes the left semi join of `this` `Dataset` with the `other` `Dataset`, - * returning a `Tuple2` for each pair where condition evaluates to true. - */ - def joinLeftSemi[U](other: TypedDataset[U])(condition: TypedColumn[T with U, Boolean]): TypedDataset[T] = - new TypedDataset(self.dataset.join(other.dataset, condition.untyped, "leftsemi") - .as[T](TypedExpressionEncoder(encoder))) - - /** Computes the left anti join of `this` `Dataset` with the `other` `Dataset`, - * returning a `Tuple2` for each pair where condition evaluates to true. - */ - def joinLeftAnti[U](other: TypedDataset[U])(condition: TypedColumn[T with U, Boolean]): TypedDataset[T] = - new TypedDataset(self.dataset.join(other.dataset, condition.untyped, "leftanti") - .as[T](TypedExpressionEncoder(encoder))) - - /** Computes the right outer join of `this` `Dataset` with the `other` `Dataset`, - * returning a `Tuple2` for each pair where condition evaluates to true. - */ - def joinRight[U](other: TypedDataset[U])(condition: TypedColumn[T with U, Boolean]) - (implicit e: TypedEncoder[(Option[T], U)]): TypedDataset[(Option[T], U)] = - new TypedDataset(self.dataset.joinWith(other.dataset, condition.untyped, "right_outer") - .as[(Option[T], U)](TypedExpressionEncoder[(Option[T], U)])) - - private def disambiguate(join: Join): Join = { - val plan = FramelessInternals.ofRows(dataset.sparkSession, join).queryExecution.analyzed.asInstanceOf[Join] - val disambiguated = plan.condition.map(_.transform { - case FramelessInternals.DisambiguateLeft(tagged: AttributeReference) => - val leftDs = FramelessInternals.ofRows(spark, plan.left) - FramelessInternals.resolveExpr(leftDs, Seq(tagged.name)) - - case FramelessInternals.DisambiguateRight(tagged: AttributeReference) => - val rightDs = FramelessInternals.ofRows(spark, plan.right) - FramelessInternals.resolveExpr(rightDs, Seq(tagged.name)) - - case x => x - }) - plan.copy(condition = disambiguated) - } - - /** Takes a function from A => R and converts it to a UDF for TypedColumn[T, A] => TypedColumn[T, R]. - */ - def makeUDF[A: TypedEncoder, R: TypedEncoder](f: A => R): - TypedColumn[T, A] => TypedColumn[T, R] = functions.udf(f) - - /** Takes a function from (A1, A2) => R and converts it to a UDF for - * (TypedColumn[T, A1], TypedColumn[T, A2]) => TypedColumn[T, R]. - */ - def makeUDF[A1: TypedEncoder, A2: TypedEncoder, R: TypedEncoder](f: (A1, A2) => R): - (TypedColumn[T, A1], TypedColumn[T, A2]) => TypedColumn[T, R] = functions.udf(f) - - /** Takes a function from (A1, A2, A3) => R and converts it to a UDF for - * (TypedColumn[T, A1], TypedColumn[T, A2], TypedColumn[T, A3]) => TypedColumn[T, R]. - */ - def makeUDF[A1: TypedEncoder, A2: TypedEncoder, A3: TypedEncoder, R: TypedEncoder](f: (A1, A2, A3) => R): - (TypedColumn[T, A1], TypedColumn[T, A2], TypedColumn[T, A3]) => TypedColumn[T, R] = functions.udf(f) - - /** Takes a function from (A1, A2, A3, A4) => R and converts it to a UDF for - * (TypedColumn[T, A1], TypedColumn[T, A2], TypedColumn[T, A3], TypedColumn[T, A4]) => TypedColumn[T, R]. - */ - def makeUDF[A1: TypedEncoder, A2: TypedEncoder, A3: TypedEncoder, A4: TypedEncoder, R: TypedEncoder](f: (A1, A2, A3, A4) => R): - (TypedColumn[T, A1], TypedColumn[T, A2], TypedColumn[T, A3], TypedColumn[T, A4]) => TypedColumn[T, R] = functions.udf(f) - - /** Takes a function from (A1, A2, A3, A4, A5) => R and converts it to a UDF for - * (TypedColumn[T, A1], TypedColumn[T, A2], TypedColumn[T, A3], TypedColumn[T, A4], TypedColumn[T, A5]) => TypedColumn[T, R]. - */ - def makeUDF[A1: TypedEncoder, A2: TypedEncoder, A3: TypedEncoder, A4: TypedEncoder, A5: TypedEncoder, R: TypedEncoder](f: (A1, A2, A3, A4, A5) => R): - (TypedColumn[T, A1], TypedColumn[T, A2], TypedColumn[T, A3], TypedColumn[T, A4], TypedColumn[T, A5]) => TypedColumn[T, R] = functions.udf(f) - - /** Type-safe projection from type T to Tuple1[A] - * {{{ - * d.select( d('a), d('a)+d('b), ... ) - * }}} - */ - def select[A]( - ca: TypedColumn[T, A] - ): TypedDataset[A] = { - implicit val ea = ca.uencoder - - val tuple1: TypedDataset[Tuple1[A]] = selectMany(ca) - - // now we need to unpack `Tuple1[A]` to `A` - - TypedEncoder[A].catalystRepr match { - case StructType(_) => - // if column is struct, we use all its fields - val df = tuple1 - .dataset - .selectExpr("_1.*") - .as[A](TypedExpressionEncoder[A]) - - TypedDataset.create(df) - case other => - // for primitive types `Tuple1[A]` has the same schema as `A` - TypedDataset.create(tuple1.dataset.as[A](TypedExpressionEncoder[A])) - } - } - - /** Type-safe projection from type T to Tuple2[A,B] - * {{{ - * d.select( d('a), d('a)+d('b), ... ) - * }}} - */ - def select[A, B]( - ca: TypedColumn[T, A], - cb: TypedColumn[T, B] - ): TypedDataset[(A, B)] = { - implicit val (ea, eb) = (ca.uencoder, cb.uencoder) - selectMany(ca, cb) - } - - /** Type-safe projection from type T to Tuple3[A,B,...] - * {{{ - * d.select( d('a), d('a)+d('b), ... ) - * }}} - */ - def select[A, B, C]( - ca: TypedColumn[T, A], - cb: TypedColumn[T, B], - cc: TypedColumn[T, C] - ): TypedDataset[(A, B, C)] = { - implicit val (ea, eb, ec) = (ca.uencoder, cb.uencoder, cc.uencoder) - selectMany(ca, cb, cc) - } - - /** Type-safe projection from type T to Tuple4[A,B,...] - * {{{ - * d.select( d('a), d('a)+d('b), ... ) - * }}} - */ - def select[A, B, C, D]( - ca: TypedColumn[T, A], - cb: TypedColumn[T, B], - cc: TypedColumn[T, C], - cd: TypedColumn[T, D] - ): TypedDataset[(A, B, C, D)] = { - implicit val (ea, eb, ec, ed) = (ca.uencoder, cb.uencoder, cc.uencoder, cd.uencoder) - selectMany(ca, cb, cc, cd) - } - - /** Type-safe projection from type T to Tuple5[A,B,...] - * {{{ - * d.select( d('a), d('a)+d('b), ... ) - * }}} - */ - def select[A, B, C, D, E]( - ca: TypedColumn[T, A], - cb: TypedColumn[T, B], - cc: TypedColumn[T, C], - cd: TypedColumn[T, D], - ce: TypedColumn[T, E] - ): TypedDataset[(A, B, C, D, E)] = { - implicit val (ea, eb, ec, ed, ee) = - (ca.uencoder, cb.uencoder, cc.uencoder, cd.uencoder, ce.uencoder) - - selectMany(ca, cb, cc, cd, ce) - } - - /** Type-safe projection from type T to Tuple6[A,B,...] - * {{{ - * d.select( d('a), d('a)+d('b), ... ) - * }}} - */ - def select[A, B, C, D, E, F]( - ca: TypedColumn[T, A], - cb: TypedColumn[T, B], - cc: TypedColumn[T, C], - cd: TypedColumn[T, D], - ce: TypedColumn[T, E], - cf: TypedColumn[T, F] - ): TypedDataset[(A, B, C, D, E, F)] = { - implicit val (ea, eb, ec, ed, ee, ef) = - (ca.uencoder, cb.uencoder, cc.uencoder, cd.uencoder, ce.uencoder, cf.uencoder) - - selectMany(ca, cb, cc, cd, ce, cf) - } - - /** Type-safe projection from type T to Tuple7[A,B,...] - * {{{ - * d.select( d('a), d('a)+d('b), ... ) - * }}} - */ - def select[A, B, C, D, E, F, G]( - ca: TypedColumn[T, A], - cb: TypedColumn[T, B], - cc: TypedColumn[T, C], - cd: TypedColumn[T, D], - ce: TypedColumn[T, E], - cf: TypedColumn[T, F], - cg: TypedColumn[T, G] - ): TypedDataset[(A, B, C, D, E, F, G)] = { - implicit val (ea, eb, ec, ed, ee, ef, eg) = - (ca.uencoder, cb.uencoder, cc.uencoder, cd.uencoder, ce.uencoder, cf.uencoder, cg.uencoder) - - selectMany(ca, cb, cc, cd, ce, cf, cg) - } - - /** Type-safe projection from type T to Tuple8[A,B,...] - * {{{ - * d.select( d('a), d('a)+d('b), ... ) - * }}} - */ - def select[A, B, C, D, E, F, G, H]( - ca: TypedColumn[T, A], - cb: TypedColumn[T, B], - cc: TypedColumn[T, C], - cd: TypedColumn[T, D], - ce: TypedColumn[T, E], - cf: TypedColumn[T, F], - cg: TypedColumn[T, G], - ch: TypedColumn[T, H] - ): TypedDataset[(A, B, C, D, E, F, G, H)] = { - implicit val (ea, eb, ec, ed, ee, ef, eg, eh) = - (ca.uencoder, cb.uencoder, cc.uencoder, cd.uencoder, ce.uencoder, cf.uencoder, cg.uencoder, ch.uencoder) - - selectMany(ca, cb, cc, cd, ce, cf, cg, ch) - } - - /** Type-safe projection from type T to Tuple9[A,B,...] - * {{{ - * d.select( d('a), d('a)+d('b), ... ) - * }}} - */ - def select[A, B, C, D, E, F, G, H, I]( - ca: TypedColumn[T, A], - cb: TypedColumn[T, B], - cc: TypedColumn[T, C], - cd: TypedColumn[T, D], - ce: TypedColumn[T, E], - cf: TypedColumn[T, F], - cg: TypedColumn[T, G], - ch: TypedColumn[T, H], - ci: TypedColumn[T, I] - ): TypedDataset[(A, B, C, D, E, F, G, H, I)] = { - implicit val (ea, eb, ec, ed, ee, ef, eg, eh, ei) = - (ca.uencoder, cb.uencoder, cc.uencoder, cd.uencoder, ce.uencoder, cf.uencoder, cg.uencoder, ch.uencoder, ci.uencoder) - - selectMany(ca, cb, cc, cd, ce, cf, cg, ch, ci) - } - - /** Type-safe projection from type T to Tuple10[A,B,...] - * {{{ - * d.select( d('a), d('a)+d('b), ... ) - * }}} - */ - def select[A, B, C, D, E, F, G, H, I, J]( - ca: TypedColumn[T, A], - cb: TypedColumn[T, B], - cc: TypedColumn[T, C], - cd: TypedColumn[T, D], - ce: TypedColumn[T, E], - cf: TypedColumn[T, F], - cg: TypedColumn[T, G], - ch: TypedColumn[T, H], - ci: TypedColumn[T, I], - cj: TypedColumn[T, J] - ): TypedDataset[(A, B, C, D, E, F, G, H, I, J)] = { - implicit val (ea, eb, ec, ed, ee, ef, eg, eh, ei, ej) = - (ca.uencoder, cb.uencoder, cc.uencoder, cd.uencoder, ce.uencoder, cf.uencoder, cg.uencoder, ch.uencoder, ci.uencoder, cj.uencoder) - selectMany(ca, cb, cc, cd, ce, cf, cg, ch, ci, cj) - } - - object selectMany extends ProductArgs { - def applyProduct[U <: HList, Out0 <: HList, Out](columns: U) - (implicit - i0: ColumnTypes.Aux[T, U, Out0], - i1: ToTraversable.Aux[U, List, UntypedExpression[T]], - i2: Tupler.Aux[Out0, Out], - i3: TypedEncoder[Out] - ): TypedDataset[Out] = { - val base = dataset.toDF() - .select(columns.toList[UntypedExpression[T]].map(c => new Column(c.expr)):_*) - val selected = base.as[Out](TypedExpressionEncoder[Out]) - - TypedDataset.create[Out](selected) - } - } - - /** Sort each partition in the dataset using the columns selected. */ - def sortWithinPartitions[A: CatalystOrdered](ca: SortedTypedColumn[T, A]): TypedDataset[T] = - sortWithinPartitionsMany(ca) - - /** Sort each partition in the dataset using the columns selected. */ - def sortWithinPartitions[A: CatalystOrdered, B: CatalystOrdered]( - ca: SortedTypedColumn[T, A], - cb: SortedTypedColumn[T, B] - ): TypedDataset[T] = sortWithinPartitionsMany(ca, cb) - - /** Sort each partition in the dataset using the columns selected. */ - def sortWithinPartitions[A: CatalystOrdered, B: CatalystOrdered, C: CatalystOrdered]( - ca: SortedTypedColumn[T, A], - cb: SortedTypedColumn[T, B], - cc: SortedTypedColumn[T, C] - ): TypedDataset[T] = sortWithinPartitionsMany(ca, cb, cc) - - /** Sort each partition in the dataset by the given column expressions - * Default sort order is ascending. - * {{{ - * d.sortWithinPartitionsMany(d('a), d('b).desc, d('c).asc) - * }}} - */ - object sortWithinPartitionsMany extends ProductArgs { - def applyProduct[U <: HList, O <: HList](columns: U) - (implicit - i0: Mapper.Aux[SortedTypedColumn.defaultAscendingPoly.type, U, O], - i1: ToTraversable.Aux[O, List, SortedTypedColumn[T, _]] - ): TypedDataset[T] = { - val sorted = dataset.toDF() - .sortWithinPartitions(i0(columns).toList[SortedTypedColumn[T, _]].map(_.untyped):_*) - .as[T](TypedExpressionEncoder[T]) - - TypedDataset.create[T](sorted) - } - } - - /** Orders the TypedDataset using the column selected. */ - def orderBy[A: CatalystOrdered](ca: SortedTypedColumn[T, A]): TypedDataset[T] = - orderByMany(ca) - - /** Orders the TypedDataset using the columns selected. */ - def orderBy[A: CatalystOrdered, B: CatalystOrdered]( - ca: SortedTypedColumn[T, A], - cb: SortedTypedColumn[T, B] - ): TypedDataset[T] = orderByMany(ca, cb) - - /** Orders the TypedDataset using the columns selected. */ - def orderBy[A: CatalystOrdered, B: CatalystOrdered, C: CatalystOrdered]( - ca: SortedTypedColumn[T, A], - cb: SortedTypedColumn[T, B], - cc: SortedTypedColumn[T, C] - ): TypedDataset[T] = orderByMany(ca, cb, cc) - - /** Sort the dataset by any number of column expressions. - * Default sort order is ascending. - * {{{ - * d.orderByMany(d('a), d('b).desc, d('c).asc) - * }}} - */ - object orderByMany extends ProductArgs { - def applyProduct[U <: HList, O <: HList](columns: U) - (implicit - i0: Mapper.Aux[SortedTypedColumn.defaultAscendingPoly.type, U, O], - i1: ToTraversable.Aux[O, List, SortedTypedColumn[T, _]] - ): TypedDataset[T] = { - val sorted = dataset.toDF() - .orderBy(i0(columns).toList[SortedTypedColumn[T, _]].map(_.untyped):_*) - .as[T](TypedExpressionEncoder[T]) - - TypedDataset.create[T](sorted) - } - } - - /** Returns a new Dataset as a tuple with the specified - * column dropped. - * Does not allow for dropping from a single column TypedDataset - * - * {{{ - * val d: TypedDataset[Foo(a: String, b: Int...)] = ??? - * val result = TypedDataset[(Int, ...)] = d.drop('a) - * }}} - * @param column column to drop specified as a Symbol - * @param i0 LabelledGeneric derived for T - * @param i1 Remover derived for TRep and column - * @param i2 values of T with column removed - * @param i3 tupler of values - * @param i4 evidence of encoder of the tupled values - * @tparam Out Tupled return type - * @tparam TRep shapeless' record representation of T - * @tparam Removed record of T with column removed - * @tparam ValuesFromRemoved values of T with column removed as an HList - * @tparam V value type of column in T - * @return - */ - def dropTupled[Out, TRep <: HList, Removed <: HList, ValuesFromRemoved <: HList, V] - (column: Witness.Lt[Symbol]) - (implicit - i0: LabelledGeneric.Aux[T, TRep], - i1: Remover.Aux[TRep, column.T, (V, Removed)], - i2: Values.Aux[Removed, ValuesFromRemoved], - i3: Tupler.Aux[ValuesFromRemoved, Out], - i4: TypedEncoder[Out] - ): TypedDataset[Out] = { - val dropped = dataset - .toDF() - .drop(column.value.name) - .as[Out](TypedExpressionEncoder[Out]) - - TypedDataset.create[Out](dropped) - } - - /** - * Drops columns as necessary to return `U` - * - * @example - * {{{ - * case class X(i: Int, j: Int, k: Boolean) - * case class Y(i: Int, k: Boolean) - * val f: TypedDataset[X] = ??? - * val fNew: TypedDataset[Y] = f.drop[Y] - * }}} - * - * @tparam U the output type - * - * @see [[frameless.TypedDataset#project]] - */ - def drop[U](implicit projector: SmartProject[T,U]): TypedDataset[U] = project[U] - - /** Prepends a new column to the Dataset. - * - * {{{ - * case class X(i: Int, j: Int) - * val f: TypedDataset[X] = TypedDataset.create(X(1,1) :: X(1,1) :: X(1,10) :: Nil) - * val fNew: TypedDataset[(Int,Int,Boolean)] = f.withColumnTupled(f('j) === 10) - * }}} - */ - def withColumnTupled[A: TypedEncoder, H <: HList, FH <: HList, Out] - (ca: TypedColumn[T, A]) - (implicit - i0: Generic.Aux[T, H], - i1: Prepend.Aux[H, A :: HNil, FH], - i2: Tupler.Aux[FH, Out], - i3: TypedEncoder[Out] - ): TypedDataset[Out] = { - // Giving a random name to the new column (the proper name will be given by the Tuple-based encoder) - val selected = dataset.toDF().withColumn("I1X3T9CU1OP0128JYIO76TYZZA3AXHQ18RMI", ca.untyped) - .as[Out](TypedExpressionEncoder[Out]) - - TypedDataset.create[Out](selected) - } - - /** Returns a new [[frameless.TypedDataset]] with the specified column updated with a new value - * {{{ - * case class X(i: Int, j: Int) - * val f: TypedDataset[X] = TypedDataset.create(X(1,10) :: Nil) - * val fNew: TypedDataset[X] = f.withColumn('j, f('i)) // results in X(1, 1) :: Nil - * }}} - * @param column column given as a symbol to replace - * @param replacement column to replace the value with - * @param i0 Evidence that a column with the correct type and name exists - */ - def withColumnReplaced[A]( - column: Witness.Lt[Symbol], - replacement: TypedColumn[T, A] - )(implicit - i0: TypedColumn.Exists[T, column.T, A] - ): TypedDataset[T] = { - val updated = dataset.toDF().withColumn(column.value.name, replacement.untyped) - .as[T](TypedExpressionEncoder[T]) - - TypedDataset.create[T](updated) - } - - /** Adds a column to a Dataset so long as the specified output type, `U`, has - * an extra column from `T` that has type `A`. - * - * @example - * {{{ - * case class X(i: Int, j: Int) - * case class Y(i: Int, j: Int, k: Boolean) - * val f: TypedDataset[X] = TypedDataset.create(X(1,1) :: X(1,1) :: X(1,10) :: Nil) - * val fNew: TypedDataset[Y] = f.withColumn[Y](f('j) === 10) - * }}} - * @param ca The typed column to add - * @param i0 TypeEncoder for output type U - * @param i1 TypeEncoder for added column type A - * @param i2 the LabelledGeneric derived for T - * @param i3 the LabelledGeneric derived for U - * @param i4 proof no fields have been removed - * @param i5 diff from T to U - * @param i6 keys from newFields - * @param i7 the one and only new key - * @param i8 the one and only new field enforcing the type of A exists - * @param i9 the keys of U - * @param iA allows for traversing the keys of U - * @tparam U the output type - * @tparam A The added column type - * @tparam TRep shapeless' record representation of T - * @tparam URep shapeless' record representation of U - * @tparam UKeys the keys of U as an HList - * @tparam NewFields the added fields to T to get U - * @tparam NewKeys the keys of NewFields as an HList - * @tparam NewKey the first, and only, key in NewKey - * - * @see [[frameless.TypedDataset.WithColumnApply#apply]] - */ - def withColumn[U] = new WithColumnApply[U] - - class WithColumnApply[U] { - def apply[A, TRep <: HList, URep <: HList, UKeys <: HList, NewFields <: HList, NewKeys <: HList, NewKey <: Symbol] - (ca: TypedColumn[T, A]) - (implicit - i0: TypedEncoder[U], - i1: TypedEncoder[A], - i2: LabelledGeneric.Aux[T, TRep], - i3: LabelledGeneric.Aux[U, URep], - i4: Diff.Aux[TRep, URep, HNil], - i5: Diff.Aux[URep, TRep, NewFields], - i6: Keys.Aux[NewFields, NewKeys], - i7: IsHCons.Aux[NewKeys, NewKey, HNil], - i8: IsHCons.Aux[NewFields, FieldType[NewKey, A], HNil], - i9: Keys.Aux[URep, UKeys], - iA: ToTraversable.Aux[UKeys, Seq, Symbol] - ): TypedDataset[U] = { - val newColumnName = - i7.head(i6()).name - - val dfWithNewColumn = dataset - .toDF() - .withColumn(newColumnName, ca.untyped) - - val newColumns = i9.apply.to[Seq].map(_.name).map(dfWithNewColumn.col) - - val selected = dfWithNewColumn - .select(newColumns: _*) - .as[U](TypedExpressionEncoder[U]) - - TypedDataset.create[U](selected) - } - } - - /** - * Explodes a single column at a time. It only compiles if the type of column supports this operation. - * - * @example - * - * {{{ - * case class X(i: Int, j: Array[Int]) - * case class Y(i: Int, j: Int) - * - * val f: TypedDataset[X] = ??? - * val fNew: TypedDataset[Y] = f.explode('j).as[Y] - * }}} - * @param column the column we wish to explode - */ - def explode[A, TRep <: HList, V[_], OutMod <: HList, OutModValues <: HList, Out] - (column: Witness.Lt[Symbol]) - (implicit - i0: TypedColumn.Exists[T, column.T, V[A]], - i1: TypedEncoder[A], - i2: CatalystExplodableCollection[V], - i3: LabelledGeneric.Aux[T, TRep], - i4: Modifier.Aux[TRep, column.T, V[A], A, OutMod], - i5: Values.Aux[OutMod, OutModValues], - i6: Tupler.Aux[OutModValues, Out], - i7: TypedEncoder[Out] - ): TypedDataset[Out] = { - val df = dataset.toDF() - import org.apache.spark.sql.functions.{explode => sparkExplode} - - val trans = - df.withColumn(column.value.name, - sparkExplode(df(column.value.name))).as[Out](TypedExpressionEncoder[Out]) - TypedDataset.create[Out](trans) - } - - /** - * Flattens a column of type Option[A]. Compiles only if the selected column is of type Option[A]. - * - * - * @example - * - * {{{ - * case class X(i: Int, j: Option[Int]) - * case class Y(i: Int, j: Int) - * - * val f: TypedDataset[X] = ??? - * val fNew: TypedDataset[Y] = f.flattenOption('j).as[Y] - * }}} - * - * @param column the column we wish to flatten - */ - def flattenOption[A, TRep <: HList, V[_], OutMod <: HList, OutModValues <: HList, Out] - (column: Witness.Lt[Symbol]) - (implicit - i0: TypedColumn.Exists[T, column.T, V[A]], - i1: TypedEncoder[A], - i2: V[A] =:= Option[A], - i3: LabelledGeneric.Aux[T, TRep], - i4: Modifier.Aux[TRep, column.T, V[A], A, OutMod], - i5: Values.Aux[OutMod, OutModValues], - i6: Tupler.Aux[OutModValues, Out], - i7: TypedEncoder[Out] - ): TypedDataset[Out] = { - val df = dataset.toDF() - val trans = - df.filter(df(column.value.name).isNotNull).as[Out](TypedExpressionEncoder[Out]) - TypedDataset.create[Out](trans) - } -} - -object TypedDataset { - def create[A](data: Seq[A]) - (implicit - encoder: TypedEncoder[A], - sqlContext: SparkSession - ): TypedDataset[A] = { - val dataset = sqlContext.createDataset(data)(TypedExpressionEncoder[A]) - TypedDataset.create[A](dataset) - } - - def create[A](data: RDD[A]) - (implicit - encoder: TypedEncoder[A], - sqlContext: SparkSession - ): TypedDataset[A] = { - val dataset = sqlContext.createDataset(data)(TypedExpressionEncoder[A]) - TypedDataset.create[A](dataset) - } - - def create[A: TypedEncoder](dataset: Dataset[A]): TypedDataset[A] = createUnsafe(dataset.toDF()) - - /** - * Creates a [[frameless.TypedDataset]] from a Spark [[org.apache.spark.sql.DataFrame]]. - * Note that the names and types need to align! - * - * This is an unsafe operation: If the schemas do not align, - * the error will be captured at runtime (not during compilation). - */ - def createUnsafe[A: TypedEncoder](df: DataFrame): TypedDataset[A] = { - val e = TypedEncoder[A] - val output: Seq[Attribute] = df.queryExecution.analyzed.output - - val targetFields = TypedExpressionEncoder.targetStructType(e) - val targetColNames: Seq[String] = targetFields.map(_.name) - - if (output.size != targetFields.size) { - throw new IllegalStateException( - s"Unsupported creation of TypedDataset with ${targetFields.size} column(s) " + - s"from a DataFrame with ${output.size} columns. " + - "Try to `select()` the proper columns in the right order before calling `create()`.") - } - - // Adapt names if they are not the same (note: types still might not match) - val shouldReshape = output.zip(targetColNames).exists { - case (expr, colName) => expr.name != colName - } - val canSelect = targetColNames.toSet.subsetOf(output.map(_.name).toSet) - - val reshaped = if (shouldReshape && canSelect) { - df.select(targetColNames.head, targetColNames.tail:_*) - } else if (shouldReshape) { - df.toDF(targetColNames: _*) - } else { - df - } - - new TypedDataset[A](reshaped.as[A](TypedExpressionEncoder[A])) - } - - /** Prefer `TypedDataset.create` over `TypedDataset.unsafeCreate` unless you - * know what you are doing. */ - @deprecated("Prefer TypedDataset.create over TypedDataset.unsafeCreate", "0.3.0") - def unsafeCreate[A: TypedEncoder](dataset: Dataset[A]): TypedDataset[A] = { - new TypedDataset[A](dataset) - } -} diff --git a/dataset/src/main/scala/frameless/TypedDatasetForwarded.scala b/dataset/src/main/scala/frameless/TypedDatasetForwarded.scala deleted file mode 100644 index ca72b9daf..000000000 --- a/dataset/src/main/scala/frameless/TypedDatasetForwarded.scala +++ /dev/null @@ -1,377 +0,0 @@ -package frameless - -import java.util - -import org.apache.spark.rdd.RDD -import org.apache.spark.sql.execution.QueryExecution -import org.apache.spark.sql.streaming.DataStreamWriter -import org.apache.spark.sql.types.StructType -import org.apache.spark.sql.{DataFrame, DataFrameWriter, SQLContext, SparkSession} -import org.apache.spark.storage.StorageLevel - -import scala.util.Random - -/** This trait implements [[TypedDataset]] methods that have the same signature - * than their `Dataset` equivalent. Each method simply forwards the call to the - * underlying `Dataset`. - * - * Documentation marked "apache/spark" is thanks to apache/spark Contributors - * at https://github.com/apache/spark, licensed under Apache v2.0 available at - * http://www.apache.org/licenses/LICENSE-2.0 - */ -trait TypedDatasetForwarded[T] { self: TypedDataset[T] => - - override def toString: String = - dataset.toString - - /** - * Returns a `SparkSession` from this [[TypedDataset]]. - */ - def sparkSession: SparkSession = - dataset.sparkSession - - /** - * Returns a `SQLContext` from this [[TypedDataset]]. - */ - def sqlContext: SQLContext = - dataset.sqlContext - - /** - * Returns the schema of this Dataset. - * - * apache/spark - */ - def schema: StructType = - dataset.schema - - /** Prints the schema of the underlying `Dataset` to the console in a nice tree format. - * - * apache/spark - */ - def printSchema(): Unit = - dataset.printSchema() - - /** Prints the plans (logical and physical) to the console for debugging purposes. - * - * apache/spark - */ - def explain(extended: Boolean = false): Unit = - dataset.explain(extended) - - /** - * Returns a `QueryExecution` from this [[TypedDataset]]. - * - * It is the primary workflow for executing relational queries using Spark. Designed to allow easy - * access to the intermediate phases of query execution for developers. - * - * apache/spark - */ - def queryExecution: QueryExecution = - dataset.queryExecution - - /** Converts this strongly typed collection of data to generic Dataframe. In contrast to the - * strongly typed objects that Dataset operations work on, a Dataframe returns generic Row - * objects that allow fields to be accessed by ordinal or name. - * - * apache/spark - */ - def toDF(): DataFrame = - dataset.toDF() - - /** Converts this [[TypedDataset]] to an RDD. - * - * apache/spark - */ - def rdd: RDD[T] = - dataset.rdd - - /** Returns a new [[TypedDataset]] that has exactly `numPartitions` partitions. - * - * apache/spark - */ - def repartition(numPartitions: Int): TypedDataset[T] = - TypedDataset.create(dataset.repartition(numPartitions)) - - - /** - * Get the [[TypedDataset]]'s current storage level, or StorageLevel.NONE if not persisted. - * - * apache/spark - */ - def storageLevel(): StorageLevel = - dataset.storageLevel - - /** - * Returns the content of the [[TypedDataset]] as a Dataset of JSON strings. - * - * apache/spark - */ - def toJSON: TypedDataset[String] = - TypedDataset.create(dataset.toJSON) - - /** - * Interface for saving the content of the non-streaming [[TypedDataset]] out into external storage. - * - * apache/spark - */ - def write: DataFrameWriter[T] = - dataset.write - - /** - * Interface for saving the content of the streaming Dataset out into external storage. - * - * apache/spark - */ - def writeStream: DataStreamWriter[T] = - dataset.writeStream - - /** Returns a new [[TypedDataset]] that has exactly `numPartitions` partitions. - * Similar to coalesce defined on an RDD, this operation results in a narrow dependency, e.g. - * if you go from 1000 partitions to 100 partitions, there will not be a shuffle, instead each of - * the 100 new partitions will claim 10 of the current partitions. - * - * apache/spark - */ - def coalesce(numPartitions: Int): TypedDataset[T] = - TypedDataset.create(dataset.coalesce(numPartitions)) - - /** - * Returns an `Array` that contains all column names in this [[TypedDataset]]. - */ - def columns: Array[String] = - dataset.columns - - /** Concise syntax for chaining custom transformations. - * - * apache/spark - */ - def transform[U](t: TypedDataset[T] => TypedDataset[U]): TypedDataset[U] = - t(this) - - /** Returns a new Dataset by taking the first `n` rows. The difference between this function - * and `head` is that `head` is an action and returns an array (by triggering query execution) - * while `limit` returns a new Dataset. - * - * apache/spark - */ - def limit(n: Int): TypedDataset[T] = - TypedDataset.create(dataset.limit(n)) - - /** Returns a new [[TypedDataset]] by sampling a fraction of records. - * - * apache/spark - */ - def sample(withReplacement: Boolean, fraction: Double, seed: Long = Random.nextLong): TypedDataset[T] = - TypedDataset.create(dataset.sample(withReplacement, fraction, seed)) - - /** Returns a new [[TypedDataset]] that contains only the unique elements of this [[TypedDataset]]. - * - * Note that, equality checking is performed directly on the encoded representation of the data - * and thus is not affected by a custom `equals` function defined on `T`. - * - * apache/spark - */ - def distinct: TypedDataset[T] = - TypedDataset.create(dataset.distinct) - - /** - * Returns a best-effort snapshot of the files that compose this [[TypedDataset]]. This method simply - * asks each constituent BaseRelation for its respective files and takes the union of all results. - * Depending on the source relations, this may not find all input files. Duplicates are removed. - * - * apache/spark - */ - - def inputFiles: Array[String] = - dataset.inputFiles - - /** - * Returns true if the `collect` and `take` methods can be run locally - * (without any Spark executors). - * - * apache/spark - */ - def isLocal: Boolean = - dataset.isLocal - - /** - * Returns true if this [[TypedDataset]] contains one or more sources that continuously - * return data as it arrives. A [[TypedDataset]] that reads data from a streaming source - * must be executed as a `StreamingQuery` using the `start()` method in - * `DataStreamWriter`. Methods that return a single answer, e.g. `count()` or - * `collect()`, will throw an `AnalysisException` when there is a streaming - * source present. - * - * apache/spark - */ - def isStreaming: Boolean = - dataset.isStreaming - - /** Returns a new [[TypedDataset]] that contains only the elements of this [[TypedDataset]] that are also - * present in `other`. - * - * Note that, equality checking is performed directly on the encoded representation of the data - * and thus is not affected by a custom `equals` function defined on `T`. - * - * apache/spark - */ - def intersect(other: TypedDataset[T]): TypedDataset[T] = - TypedDataset.create(dataset.intersect(other.dataset)) - - /** - * Randomly splits this [[TypedDataset]] with the provided weights. - * Weights for splits, will be normalized if they don't sum to 1. - * - * apache/spark - */ - // $COVERAGE-OFF$ We can not test this method because it is non-deterministic. - def randomSplit(weights: Array[Double]): Array[TypedDataset[T]] = - dataset.randomSplit(weights).map(TypedDataset.create[T]) - // $COVERAGE-ON$ - - /** - * Randomly splits this [[TypedDataset]] with the provided weights. - * Weights for splits, will be normalized if they don't sum to 1. - * - * apache/spark - */ - def randomSplit(weights: Array[Double], seed: Long): Array[TypedDataset[T]] = - dataset.randomSplit(weights, seed).map(TypedDataset.create[T]) - - /** - * Returns a Java list that contains randomly split [[TypedDataset]] with the provided weights. - * Weights for splits, will be normalized if they don't sum to 1. - * - * apache/spark - */ - def randomSplitAsList(weights: Array[Double], seed: Long): util.List[TypedDataset[T]] = { - val values = randomSplit(weights, seed) - java.util.Arrays.asList(values: _*) - } - - - /** Returns a new Dataset containing rows in this Dataset but not in another Dataset. - * This is equivalent to `EXCEPT` in SQL. - * - * Note that, equality checking is performed directly on the encoded representation of the data - * and thus is not affected by a custom `equals` function defined on `T`. - * - * apache/spark - */ - def except(other: TypedDataset[T]): TypedDataset[T] = - TypedDataset.create(dataset.except(other.dataset)) - - /** Persist this [[TypedDataset]] with the default storage level (`MEMORY_AND_DISK`). - * - * apache/spark - */ - def cache(): TypedDataset[T] = - TypedDataset.create(dataset.cache()) - - /** Persist this [[TypedDataset]] with the given storage level. - * @param newLevel One of: `MEMORY_ONLY`, `MEMORY_AND_DISK`, `MEMORY_ONLY_SER`, - * `MEMORY_AND_DISK_SER`, `DISK_ONLY`, `MEMORY_ONLY_2`, `MEMORY_AND_DISK_2`, etc. - * - * apache/spark - */ - def persist(newLevel: StorageLevel = StorageLevel.MEMORY_AND_DISK): TypedDataset[T] = - TypedDataset.create(dataset.persist(newLevel)) - - /** Mark the [[TypedDataset]] as non-persistent, and remove all blocks for it from memory and disk. - * @param blocking Whether to block until all blocks are deleted. - * - * apache/spark - */ - def unpersist(blocking: Boolean = false): TypedDataset[T] = - TypedDataset.create(dataset.unpersist(blocking)) - - // $COVERAGE-OFF$ We do not test deprecated method since forwarded methods are tested. - @deprecated("deserialized methods have moved to a separate section to highlight their runtime overhead", "0.4.0") - def map[U: TypedEncoder](func: T => U): TypedDataset[U] = - deserialized.map(func) - - @deprecated("deserialized methods have moved to a separate section to highlight their runtime overhead", "0.4.0") - def mapPartitions[U: TypedEncoder](func: Iterator[T] => Iterator[U]): TypedDataset[U] = - deserialized.mapPartitions(func) - - @deprecated("deserialized methods have moved to a separate section to highlight their runtime overhead", "0.4.0") - def flatMap[U: TypedEncoder](func: T => TraversableOnce[U]): TypedDataset[U] = - deserialized.flatMap(func) - - @deprecated("deserialized methods have moved to a separate section to highlight their runtime overhead", "0.4.0") - def filter(func: T => Boolean): TypedDataset[T] = - deserialized.filter(func) - - @deprecated("deserialized methods have moved to a separate section to highlight their runtime overhead", "0.4.0") - def reduceOption[F[_]: SparkDelay](func: (T, T) => T): F[Option[T]] = - deserialized.reduceOption(func) - // $COVERAGE-ON$ - - /** Methods on `TypedDataset[T]` that go through a full serialization and - * deserialization of `T`, and execute outside of the Catalyst runtime. - * - * @example The correct way to do a projection on a single column is to - * use the `select` method as follows: - * - * {{{ - * ds: TypedDataset[(String, String, String)] -> ds.select(ds('_2)).run() - * }}} - * - * Spark provides an alternative way to obtain the same resulting `Dataset`, - * using the `map` method: - * - * {{{ - * ds: TypedDataset[(String, String, String)] -> ds.deserialized.map(_._2).run() - * }}} - * - * This second approach is however substantially slower than the first one, - * and should be avoided as possible. Indeed, under the hood this `map` will - * deserialize the entire `Tuple3` to an full JVM object, call the apply - * method of the `_._2` closure on it, and serialize the resulting String back - * to its Catalyst representation. - */ - object deserialized { - /** Returns a new [[TypedDataset]] that contains the result of applying `func` to each element. - * - * apache/spark - */ - def map[U: TypedEncoder](func: T => U): TypedDataset[U] = - TypedDataset.create(self.dataset.map(func)(TypedExpressionEncoder[U])) - - /** Returns a new [[TypedDataset]] that contains the result of applying `func` to each partition. - * - * apache/spark - */ - def mapPartitions[U: TypedEncoder](func: Iterator[T] => Iterator[U]): TypedDataset[U] = - TypedDataset.create(self.dataset.mapPartitions(func)(TypedExpressionEncoder[U])) - - /** Returns a new [[TypedDataset]] by first applying a function to all elements of this [[TypedDataset]], - * and then flattening the results. - * - * apache/spark - */ - def flatMap[U: TypedEncoder](func: T => TraversableOnce[U]): TypedDataset[U] = - TypedDataset.create(self.dataset.flatMap(func)(TypedExpressionEncoder[U])) - - /** Returns a new [[TypedDataset]] that only contains elements where `func` returns `true`. - * - * apache/spark - */ - def filter(func: T => Boolean): TypedDataset[T] = - TypedDataset.create(self.dataset.filter(func)) - - /** Optionally reduces the elements of this [[TypedDataset]] using the specified binary function. The given - * `func` must be commutative and associative or the result may be non-deterministic. - * - * Differs from `Dataset#reduce` by wrapping its result into an `Option` and an effect-suspending `F`. - */ - def reduceOption[F[_]](func: (T, T) => T)(implicit F: SparkDelay[F]): F[Option[T]] = - F.delay { - try { - Option(self.dataset.reduce(func)) - } catch { - case _: UnsupportedOperationException => None - } - }(self.dataset.sparkSession) - } -} diff --git a/dataset/src/main/scala/frameless/TypedEncoder.scala b/dataset/src/main/scala/frameless/TypedEncoder.scala deleted file mode 100644 index 47104e8a4..000000000 --- a/dataset/src/main/scala/frameless/TypedEncoder.scala +++ /dev/null @@ -1,431 +0,0 @@ -package frameless - -import org.apache.spark.sql.FramelessInternals -import org.apache.spark.sql.FramelessInternals.UserDefinedType -import org.apache.spark.sql.catalyst.ScalaReflection -import org.apache.spark.sql.catalyst.expressions._ -import org.apache.spark.sql.catalyst.expressions.objects._ -import org.apache.spark.sql.catalyst.util.{ArrayBasedMapData, GenericArrayData} -import org.apache.spark.sql.types._ -import org.apache.spark.unsafe.types.UTF8String -import shapeless._ -import shapeless.ops.hlist.IsHCons - -import scala.reflect.ClassTag - -abstract class TypedEncoder[T](implicit val classTag: ClassTag[T]) extends Serializable { - def nullable: Boolean - - def jvmRepr: DataType - def catalystRepr: DataType - - /** From Catalyst representation to T - */ - def fromCatalyst(path: Expression): Expression - - /** T to Catalyst representation - */ - def toCatalyst(path: Expression): Expression -} - -// Waiting on scala 2.12 -// @annotation.implicitAmbiguous(msg = -// """TypedEncoder[${T}] can be obtained from automatic type class derivation, using the implicit Injection[${T}, ?] or using the implicit UserDefinedType[${T}] in scope. -// To desambigious this resolution you need to either: -// - Remove the implicit Injection[${T}, ?] from scope -// - Remove the implicit UserDefinedType[${T}] from scope -// - import TypedEncoder.usingInjection -// - import TypedEncoder.usingDerivation -// - import TypedEncoder.usingUserDefinedType -// """) -object TypedEncoder { - def apply[T: TypedEncoder]: TypedEncoder[T] = implicitly[TypedEncoder[T]] - - implicit val stringEncoder: TypedEncoder[String] = new TypedEncoder[String] { - def nullable: Boolean = false - - def jvmRepr: DataType = FramelessInternals.objectTypeFor[String] - def catalystRepr: DataType = StringType - - def toCatalyst(path: Expression): Expression = - StaticInvoke(classOf[UTF8String], catalystRepr, "fromString", path :: Nil) - - def fromCatalyst(path: Expression): Expression = - Invoke(path, "toString", jvmRepr) - } - - implicit val booleanEncoder: TypedEncoder[Boolean] = new TypedEncoder[Boolean] { - def nullable: Boolean = false - - def jvmRepr: DataType = BooleanType - def catalystRepr: DataType = BooleanType - - def toCatalyst(path: Expression): Expression = path - def fromCatalyst(path: Expression): Expression = path - } - - implicit val intEncoder: TypedEncoder[Int] = new TypedEncoder[Int] { - def nullable: Boolean = false - - def jvmRepr: DataType = IntegerType - def catalystRepr: DataType = IntegerType - - def toCatalyst(path: Expression): Expression = path - def fromCatalyst(path: Expression): Expression = path - } - - implicit val longEncoder: TypedEncoder[Long] = new TypedEncoder[Long] { - def nullable: Boolean = false - - def jvmRepr: DataType = LongType - def catalystRepr: DataType = LongType - - def toCatalyst(path: Expression): Expression = path - def fromCatalyst(path: Expression): Expression = path - } - - implicit val shortEncoder: TypedEncoder[Short] = new TypedEncoder[Short] { - def nullable: Boolean = false - - def jvmRepr: DataType = ShortType - def catalystRepr: DataType = ShortType - - def toCatalyst(path: Expression): Expression = path - def fromCatalyst(path: Expression): Expression = path - } - - implicit val charEncoder: TypedEncoder[Char] = new TypedEncoder[Char] { - // tricky because while Char is primitive type, Spark doesn't support it - implicit val charAsString: Injection[java.lang.Character, String] = new Injection[java.lang.Character, String] { - def apply(a: java.lang.Character): String = String.valueOf(a) - def invert(b: String): java.lang.Character = { - require(b.length == 1) - b.charAt(0) - } - } - - val underlying = usingInjection[java.lang.Character, String] - - def nullable: Boolean = false - - // this line fixes underlying encoder - def jvmRepr: DataType = FramelessInternals.objectTypeFor[java.lang.Character] - def catalystRepr: DataType = StringType - - def toCatalyst(path: Expression): Expression = underlying.toCatalyst(path) - def fromCatalyst(path: Expression): Expression = underlying.fromCatalyst(path) - } - - implicit val byteEncoder: TypedEncoder[Byte] = new TypedEncoder[Byte] { - def nullable: Boolean = false - - def jvmRepr: DataType = ByteType - def catalystRepr: DataType = ByteType - - def toCatalyst(path: Expression): Expression = path - def fromCatalyst(path: Expression): Expression = path - } - - implicit val floatEncoder: TypedEncoder[Float] = new TypedEncoder[Float] { - def nullable: Boolean = false - - def jvmRepr: DataType = FloatType - def catalystRepr: DataType = FloatType - - def toCatalyst(path: Expression): Expression = path - def fromCatalyst(path: Expression): Expression = path - } - - implicit val doubleEncoder: TypedEncoder[Double] = new TypedEncoder[Double] { - def nullable: Boolean = false - - def jvmRepr: DataType = DoubleType - def catalystRepr: DataType = DoubleType - - def toCatalyst(path: Expression): Expression = path - def fromCatalyst(path: Expression): Expression = path - } - - implicit val bigDecimalEncoder: TypedEncoder[BigDecimal] = new TypedEncoder[BigDecimal] { - def nullable: Boolean = false - - def jvmRepr: DataType = ScalaReflection.dataTypeFor[BigDecimal] - def catalystRepr: DataType = DecimalType.SYSTEM_DEFAULT - - def toCatalyst(path: Expression): Expression = - StaticInvoke(Decimal.getClass, DecimalType.SYSTEM_DEFAULT, "apply", path :: Nil) - - def fromCatalyst(path: Expression): Expression = - Invoke(path, "toBigDecimal", jvmRepr) - } - - implicit val javaBigDecimalEncoder: TypedEncoder[java.math.BigDecimal] = new TypedEncoder[java.math.BigDecimal] { - def nullable: Boolean = false - - def jvmRepr: DataType = ScalaReflection.dataTypeFor[java.math.BigDecimal] - def catalystRepr: DataType = DecimalType.SYSTEM_DEFAULT - - def toCatalyst(path: Expression): Expression = - StaticInvoke(Decimal.getClass, DecimalType.SYSTEM_DEFAULT, "apply", path :: Nil) - - def fromCatalyst(path: Expression): Expression = - Invoke(path, "toJavaBigDecimal", jvmRepr) - } - - implicit val sqlDate: TypedEncoder[SQLDate] = new TypedEncoder[SQLDate] { - def nullable: Boolean = false - - def jvmRepr: DataType = ScalaReflection.dataTypeFor[SQLDate] - def catalystRepr: DataType = DateType - - def toCatalyst(path: Expression): Expression = - Invoke(path, "days", DateType) - - def fromCatalyst(path: Expression): Expression = - StaticInvoke( - staticObject = SQLDate.getClass, - dataType = jvmRepr, - functionName = "apply", - arguments = path :: Nil, - propagateNull = true - ) - } - - implicit val sqlTimestamp: TypedEncoder[SQLTimestamp] = new TypedEncoder[SQLTimestamp] { - def nullable: Boolean = false - - def jvmRepr: DataType = ScalaReflection.dataTypeFor[SQLTimestamp] - def catalystRepr: DataType = TimestampType - - def toCatalyst(path: Expression): Expression = - Invoke(path, "us", TimestampType) - - def fromCatalyst(path: Expression): Expression = - StaticInvoke( - staticObject = SQLTimestamp.getClass, - dataType = jvmRepr, - functionName = "apply", - arguments = path :: Nil, - propagateNull = true - ) - } - - implicit def arrayEncoder[T: ClassTag](implicit encodeT: TypedEncoder[T]): TypedEncoder[Array[T]] = - new TypedEncoder[Array[T]] { - def nullable: Boolean = false - - def jvmRepr: DataType = encodeT.jvmRepr match { - case ByteType => BinaryType - case _ => FramelessInternals.objectTypeFor[Array[T]] - } - - def catalystRepr: DataType = encodeT.jvmRepr match { - case ByteType => BinaryType - case _ => ArrayType(encodeT.catalystRepr, encodeT.nullable) - } - - def toCatalyst(path: Expression): Expression = - encodeT.jvmRepr match { - case IntegerType | LongType | DoubleType | FloatType | ShortType | BooleanType => - StaticInvoke(classOf[UnsafeArrayData], catalystRepr, "fromPrimitiveArray", path :: Nil) - - case ByteType => path - - case _ => MapObjects(encodeT.toCatalyst _, path, encodeT.jvmRepr, encodeT.nullable) - } - - def fromCatalyst(path: Expression): Expression = - encodeT.jvmRepr match { - case IntegerType => Invoke(path, "toIntArray", jvmRepr) - case LongType => Invoke(path, "toLongArray", jvmRepr) - case DoubleType => Invoke(path, "toDoubleArray", jvmRepr) - case FloatType => Invoke(path, "toFloatArray", jvmRepr) - case ShortType => Invoke(path, "toShortArray", jvmRepr) - case BooleanType => Invoke(path, "toBooleanArray", jvmRepr) - - case ByteType => path - - case _ => - Invoke(MapObjects(encodeT.fromCatalyst _, path, encodeT.catalystRepr, encodeT.nullable), "array", jvmRepr) - } - } - - implicit def collectionEncoder[C[X] <: Seq[X], T] - (implicit - encodeT: Lazy[TypedEncoder[T]], - CT: ClassTag[C[T]] - ): TypedEncoder[C[T]] = - new TypedEncoder[C[T]] { - def nullable: Boolean = false - - def jvmRepr: DataType = FramelessInternals.objectTypeFor[C[T]](CT) - - def catalystRepr: DataType = ArrayType(encodeT.value.catalystRepr, encodeT.value.nullable) - - def toCatalyst(path: Expression): Expression = - if (ScalaReflection.isNativeType(encodeT.value.jvmRepr)) - NewInstance(classOf[GenericArrayData], path :: Nil, catalystRepr) - else MapObjects(encodeT.value.toCatalyst _, path, encodeT.value.jvmRepr, encodeT.value.nullable) - - def fromCatalyst(path: Expression): Expression = - MapObjects( - encodeT.value.fromCatalyst, - path, - encodeT.value.catalystRepr, - encodeT.value.nullable, - Some(CT.runtimeClass) // This will cause MapObjects to build a collection of type C[_] directly - ) - } - - implicit def mapEncoder[A: NotCatalystNullable, B] - (implicit - encodeA: TypedEncoder[A], - encodeB: TypedEncoder[B] - ): TypedEncoder[Map[A, B]] = new TypedEncoder[Map[A, B]] { - def nullable: Boolean = false - - def jvmRepr: DataType = FramelessInternals.objectTypeFor[Map[A, B]] - - def catalystRepr: DataType = MapType(encodeA.catalystRepr, encodeB.catalystRepr, encodeB.nullable) - - def fromCatalyst(path: Expression): Expression = { - val keyArrayType = ArrayType(encodeA.catalystRepr, containsNull = false) - val keyData = Invoke( - MapObjects( - encodeA.fromCatalyst, - Invoke(path, "keyArray", keyArrayType), - encodeA.catalystRepr - ), - "array", - FramelessInternals.objectTypeFor[Array[Any]] - ) - - val valueArrayType = ArrayType(encodeB.catalystRepr, encodeB.nullable) - val valueData = Invoke( - MapObjects( - encodeB.fromCatalyst, - Invoke(path, "valueArray", valueArrayType), - encodeB.catalystRepr - ), - "array", - FramelessInternals.objectTypeFor[Array[Any]] - ) - - StaticInvoke( - ArrayBasedMapData.getClass, - jvmRepr, - "toScalaMap", - keyData :: valueData :: Nil) - } - - def toCatalyst(path: Expression): Expression = ExternalMapToCatalyst( - path, - encodeA.jvmRepr, - encodeA.toCatalyst, - encodeA.nullable, - encodeB.jvmRepr, - encodeB.toCatalyst, - encodeB.nullable) - } - - implicit def optionEncoder[A](implicit underlying: TypedEncoder[A]): TypedEncoder[Option[A]] = - new TypedEncoder[Option[A]] { - def nullable: Boolean = true - - def jvmRepr: DataType = FramelessInternals.objectTypeFor[Option[A]](classTag) - def catalystRepr: DataType = underlying.catalystRepr - - def toCatalyst(path: Expression): Expression = { - // for primitive types we must manually unbox the value of the object - underlying.jvmRepr match { - case IntegerType => - Invoke( - UnwrapOption(ScalaReflection.dataTypeFor[java.lang.Integer], path), - "intValue", - IntegerType) - case LongType => - Invoke( - UnwrapOption(ScalaReflection.dataTypeFor[java.lang.Long], path), - "longValue", - LongType) - case DoubleType => - Invoke( - UnwrapOption(ScalaReflection.dataTypeFor[java.lang.Double], path), - "doubleValue", - DoubleType) - case FloatType => - Invoke( - UnwrapOption(ScalaReflection.dataTypeFor[java.lang.Float], path), - "floatValue", - FloatType) - case ShortType => - Invoke( - UnwrapOption(ScalaReflection.dataTypeFor[java.lang.Short], path), - "shortValue", - ShortType) - case ByteType => - Invoke( - UnwrapOption(ScalaReflection.dataTypeFor[java.lang.Byte], path), - "byteValue", - ByteType) - case BooleanType => - Invoke( - UnwrapOption(ScalaReflection.dataTypeFor[java.lang.Boolean], path), - "booleanValue", - BooleanType) - - case _ => underlying.toCatalyst(UnwrapOption(underlying.jvmRepr, path)) - } - } - - def fromCatalyst(path: Expression): Expression = - WrapOption(underlying.fromCatalyst(path), underlying.jvmRepr) - } - - /** Encodes things using injection if there is one defined */ - implicit def usingInjection[A: ClassTag, B] - (implicit inj: Injection[A, B], trb: TypedEncoder[B]): TypedEncoder[A] = - new TypedEncoder[A] { - def nullable: Boolean = trb.nullable - def jvmRepr: DataType = FramelessInternals.objectTypeFor[A](classTag) - def catalystRepr: DataType = trb.catalystRepr - - def fromCatalyst(path: Expression): Expression = { - val bexpr = trb.fromCatalyst(path) - Invoke(Literal.fromObject(inj), "invert", jvmRepr, Seq(bexpr)) - } - - def toCatalyst(path: Expression): Expression = { - val invoke = Invoke(Literal.fromObject(inj), "apply", trb.jvmRepr, Seq(path)) - trb.toCatalyst(invoke) - } - } - - /** Encodes things as records if there is no Injection defined */ - implicit def usingDerivation[F, G <: HList, H <: HList] - (implicit - i0: LabelledGeneric.Aux[F, G], - i1: DropUnitValues.Aux[G, H], - i2: IsHCons[H], - i3: Lazy[RecordEncoderFields[H]], - i4: Lazy[NewInstanceExprs[G]], - i5: ClassTag[F] - ): TypedEncoder[F] = new RecordEncoder[F, G, H] - - /** Encodes things using a Spark SQL's User Defined Type (UDT) if there is one defined in implicit */ - implicit def usingUserDefinedType[A >: Null : UserDefinedType : ClassTag]: TypedEncoder[A] = { - val udt = implicitly[UserDefinedType[A]] - val udtInstance = NewInstance(udt.getClass, Nil, dataType = ObjectType(udt.getClass)) - - new TypedEncoder[A] { - def nullable: Boolean = false - def jvmRepr: DataType = ObjectType(udt.userClass) - def catalystRepr: DataType = udt - - def toCatalyst(path: Expression): Expression = Invoke(udtInstance, "serialize", udt, Seq(path)) - - def fromCatalyst(path: Expression): Expression = - Invoke(udtInstance, "deserialize", ObjectType(udt.userClass), Seq(path)) - } - } -} diff --git a/dataset/src/main/scala/frameless/TypedExpressionEncoder.scala b/dataset/src/main/scala/frameless/TypedExpressionEncoder.scala deleted file mode 100644 index c8fbf88d7..000000000 --- a/dataset/src/main/scala/frameless/TypedExpressionEncoder.scala +++ /dev/null @@ -1,46 +0,0 @@ -package frameless - -import org.apache.spark.sql.Encoder -import org.apache.spark.sql.catalyst.analysis.GetColumnByOrdinal -import org.apache.spark.sql.catalyst.encoders.ExpressionEncoder -import org.apache.spark.sql.catalyst.expressions.{BoundReference, CreateNamedStruct, If} -import org.apache.spark.sql.types.StructType - -object TypedExpressionEncoder { - - /** In Spark, DataFrame has always schema of StructType - * - * DataFrames of primitive types become records with a single field called "value" set in ExpressionEncoder. - */ - def targetStructType[A](encoder: TypedEncoder[A]): StructType = { - encoder.catalystRepr match { - case x: StructType => - if (encoder.nullable) StructType(x.fields.map(_.copy(nullable = true))) - else x - case dt => new StructType().add("value", dt, nullable = encoder.nullable) - } - } - - def apply[T: TypedEncoder]: Encoder[T] = { - val encoder = TypedEncoder[T] - val in = BoundReference(0, encoder.jvmRepr, encoder.nullable) - - val (out, serializer) = encoder.toCatalyst(in) match { - case it @ If(_, _, _: CreateNamedStruct) => - val out = GetColumnByOrdinal(0, encoder.catalystRepr) - - (out, it) - case other => - val out = GetColumnByOrdinal(0, encoder.catalystRepr) - - (out, other) - } - - new ExpressionEncoder[T]( - objSerializer = serializer, - objDeserializer = encoder.fromCatalyst(out), - clsTag = encoder.classTag - ) - } -} - diff --git a/dataset/src/main/scala/frameless/functions/AggregateFunctions.scala b/dataset/src/main/scala/frameless/functions/AggregateFunctions.scala deleted file mode 100644 index 34354a280..000000000 --- a/dataset/src/main/scala/frameless/functions/AggregateFunctions.scala +++ /dev/null @@ -1,277 +0,0 @@ -package frameless -package functions - -import org.apache.spark.sql.FramelessInternals.expr -import org.apache.spark.sql.catalyst.expressions._ -import org.apache.spark.sql.{functions => sparkFunctions} -import frameless.syntax._ - -trait AggregateFunctions { - /** Aggregate function: returns the number of items in a group. - * - * apache/spark - */ - def count[T](): TypedAggregate[T, Long] = - sparkFunctions.count(sparkFunctions.lit(1)).typedAggregate - - /** Aggregate function: returns the number of items in a group for which the selected column is not null. - * - * apache/spark - */ - def count[T](column: TypedColumn[T, _]): TypedAggregate[T, Long] = - sparkFunctions.count(column.untyped).typedAggregate - - /** Aggregate function: returns the number of distinct items in a group. - * - * apache/spark - */ - def countDistinct[T](column: TypedColumn[T, _]): TypedAggregate[T, Long] = - sparkFunctions.countDistinct(column.untyped).typedAggregate - - /** Aggregate function: returns the approximate number of distinct items in a group. - */ - def approxCountDistinct[T](column: TypedColumn[T, _]): TypedAggregate[T, Long] = - sparkFunctions.approx_count_distinct(column.untyped).typedAggregate - - /** Aggregate function: returns the approximate number of distinct items in a group. - * - * @param rsd maximum estimation error allowed (default = 0.05) - * - * apache/spark - */ - def approxCountDistinct[T](column: TypedColumn[T, _], rsd: Double): TypedAggregate[T, Long] = - sparkFunctions.approx_count_distinct(column.untyped, rsd).typedAggregate - - /** Aggregate function: returns a list of objects with duplicates. - * - * apache/spark - */ - def collectList[T, A: TypedEncoder](column: TypedColumn[T, A]): TypedAggregate[T, Vector[A]] = - sparkFunctions.collect_list(column.untyped).typedAggregate - - /** Aggregate function: returns a set of objects with duplicate elements eliminated. - * - * apache/spark - */ - def collectSet[T, A: TypedEncoder](column: TypedColumn[T, A]): TypedAggregate[T, Vector[A]] = - sparkFunctions.collect_set(column.untyped).typedAggregate - - /** Aggregate function: returns the sum of all values in the given column. - * - * apache/spark - */ - def sum[A, T, Out](column: TypedColumn[T, A])( - implicit - summable: CatalystSummable[A, Out], - oencoder: TypedEncoder[Out], - aencoder: TypedEncoder[A] - ): TypedAggregate[T, Out] = { - val zeroExpr = Literal.create(summable.zero, TypedEncoder[A].catalystRepr) - val sumExpr = expr(sparkFunctions.sum(column.untyped)) - val sumOrZero = Coalesce(Seq(sumExpr, zeroExpr)) - - new TypedAggregate[T, Out](sumOrZero) - } - - /** Aggregate function: returns the sum of distinct values in the column. - * - * apache/spark - */ - def sumDistinct[A, T, Out](column: TypedColumn[T, A])( - implicit - summable: CatalystSummable[A, Out], - oencoder: TypedEncoder[Out], - aencoder: TypedEncoder[A] - ): TypedAggregate[T, Out] = { - val zeroExpr = Literal.create(summable.zero, TypedEncoder[A].catalystRepr) - val sumExpr = expr(sparkFunctions.sumDistinct(column.untyped)) - val sumOrZero = Coalesce(Seq(sumExpr, zeroExpr)) - - new TypedAggregate[T, Out](sumOrZero) - } - - /** Aggregate function: returns the average of the values in a group. - * - * apache/spark - */ - def avg[A, T, Out](column: TypedColumn[T, A])( - implicit - averageable: CatalystAverageable[A, Out], - oencoder: TypedEncoder[Out] - ): TypedAggregate[T, Out] = { - new TypedAggregate[T, Out](sparkFunctions.avg(column.untyped)) - } - - /** Aggregate function: returns the unbiased variance of the values in a group. - * - * @note In Spark variance always returns Double - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/CentralMomentAgg.scala#186]] - * - * apache/spark - */ - def variance[A: CatalystVariance, T](column: TypedColumn[T, A]): TypedAggregate[T, Double] = - sparkFunctions.variance(column.untyped).typedAggregate - - /** Aggregate function: returns the sample standard deviation. - * - * @note In Spark stddev always returns Double - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/CentralMomentAgg.scala#155]] - * - * apache/spark - */ - def stddev[A: CatalystVariance, T](column: TypedColumn[T, A]): TypedAggregate[T, Double] = - sparkFunctions.stddev(column.untyped).typedAggregate - - /** - * Aggregate function: returns the standard deviation of a column by population. - * - * @note In Spark stddev always returns Double - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/CentralMomentAgg.scala#L143]] - * - * apache/spark - */ - def stddevPop[A, T](column: TypedColumn[T, A])(implicit ev: CatalystCast[A, Double]): TypedAggregate[T, Option[Double]] = { - new TypedAggregate[T, Option[Double]]( - sparkFunctions.stddev_pop(column.cast[Double].untyped) - ) - } - - /** - * Aggregate function: returns the standard deviation of a column by sample. - * - * @note In Spark stddev always returns Double - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/CentralMomentAgg.scala#L160]] - * - * apache/spark - */ - def stddevSamp[A, T](column: TypedColumn[T, A])(implicit ev: CatalystCast[A, Double] ): TypedAggregate[T, Option[Double]] = { - new TypedAggregate[T, Option[Double]]( - sparkFunctions.stddev_samp(column.cast[Double].untyped) - ) - } - - /** Aggregate function: returns the maximum value of the column in a group. - * - * apache/spark - */ - def max[A: CatalystOrdered, T](column: TypedColumn[T, A]): TypedAggregate[T, A] = { - implicit val c = column.uencoder - sparkFunctions.max(column.untyped).typedAggregate - } - - /** Aggregate function: returns the minimum value of the column in a group. - * - * apache/spark - */ - def min[A: CatalystOrdered, T](column: TypedColumn[T, A]): TypedAggregate[T, A] = { - implicit val c = column.uencoder - sparkFunctions.min(column.untyped).typedAggregate - } - - /** Aggregate function: returns the first value in a group. - * - * The function by default returns the first values it sees. It will return the first non-null - * value it sees when ignoreNulls is set to true. If all values are null, then null is returned. - * - * apache/spark - */ - def first[A, T](column: TypedColumn[T, A]): TypedAggregate[T, A] = { - sparkFunctions.first(column.untyped).typedAggregate(column.uencoder) - } - - /** - * Aggregate function: returns the last value in a group. - * - * The function by default returns the last values it sees. It will return the last non-null - * value it sees when ignoreNulls is set to true. If all values are null, then null is returned. - * - * apache/spark - */ - def last[A, T](column: TypedColumn[T, A]): TypedAggregate[T, A] = { - implicit val c = column.uencoder - sparkFunctions.last(column.untyped).typedAggregate - } - - /** - * Aggregate function: returns the Pearson Correlation Coefficient for two columns. - * - * @note In Spark corr always returns Double - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/Corr.scala#L95]] - * - * apache/spark - */ - def corr[A, B, T](column1: TypedColumn[T, A], column2: TypedColumn[T, B]) - (implicit - i0: CatalystCast[A, Double], - i1: CatalystCast[B, Double] - ): TypedAggregate[T, Option[Double]] = { - new TypedAggregate[T, Option[Double]]( - sparkFunctions.corr(column1.cast[Double].untyped, column2.cast[Double].untyped) - ) - } - - /** - * Aggregate function: returns the covariance of two collumns. - * - * @note In Spark covar_pop always returns Double - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/Covariance.scala#L82]] - * - * apache/spark - */ - def covarPop[A, B, T](column1: TypedColumn[T, A], column2: TypedColumn[T, B]) - (implicit - i0: CatalystCast[A, Double], - i1: CatalystCast[B, Double] - ): TypedAggregate[T, Option[Double]] = { - new TypedAggregate[T, Option[Double]]( - sparkFunctions.covar_pop(column1.cast[Double].untyped, column2.cast[Double].untyped) - ) - } - - /** - * Aggregate function: returns the covariance of two columns. - * - * @note In Spark covar_samp always returns Double - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/Covariance.scala#L93]] - * - * apache/spark - */ - def covarSamp[A, B, T](column1: TypedColumn[T, A], column2: TypedColumn[T, B]) - (implicit - i0: CatalystCast[A, Double], - i1: CatalystCast[B, Double] - ): TypedAggregate[T, Option[Double]] = { - new TypedAggregate[T, Option[Double]]( - sparkFunctions.covar_samp(column1.cast[Double].untyped, column2.cast[Double].untyped) - ) - } - - - /** - * Aggregate function: returns the kurtosis of a column. - * - * @note In Spark kurtosis always returns Double - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/CentralMomentAgg.scala#L220]] - * - * apache/spark - */ - def kurtosis[A, T](column: TypedColumn[T, A])(implicit ev: CatalystCast[A, Double]): TypedAggregate[T, Option[Double]] = { - new TypedAggregate[T, Option[Double]]( - sparkFunctions.kurtosis(column.cast[Double].untyped) - ) - } - - /** - * Aggregate function: returns the skewness of a column. - * - * @note In Spark skewness always returns Double - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/CentralMomentAgg.scala#L200]] - * - * apache/spark - */ - def skewness[A, T](column: TypedColumn[T, A])(implicit ev: CatalystCast[A, Double]): TypedAggregate[T, Option[Double]] = { - new TypedAggregate[T, Option[Double]]( - sparkFunctions.skewness(column.cast[Double].untyped) - ) - } -} diff --git a/dataset/src/main/scala/frameless/functions/Lit.scala b/dataset/src/main/scala/frameless/functions/Lit.scala deleted file mode 100644 index 75393ea26..000000000 --- a/dataset/src/main/scala/frameless/functions/Lit.scala +++ /dev/null @@ -1,57 +0,0 @@ -package frameless.functions - -import frameless.TypedEncoder -import org.apache.spark.sql.catalyst.InternalRow -import org.apache.spark.sql.catalyst.expressions.codegen._ -import org.apache.spark.sql.catalyst.expressions.{Expression, Literal, NonSQLExpression} -import org.apache.spark.sql.types.DataType - -case class FramelessLit[A](obj: A, encoder: TypedEncoder[A]) extends Expression with NonSQLExpression { - override def nullable: Boolean = encoder.nullable - override def toString: String = s"FramelessLit($obj)" - - def eval(input: InternalRow): Any = { - val ctx = new CodegenContext() - val eval = genCode(ctx) - - val codeBody = s""" - public scala.Function1 generate(Object[] references) { - return new FramelessLitEvalImpl(references); - } - - class FramelessLitEvalImpl extends scala.runtime.AbstractFunction1 { - private final Object[] references; - ${ctx.declareMutableStates()} - ${ctx.declareAddedFunctions()} - - public FramelessLitEvalImpl(Object[] references) { - this.references = references; - ${ctx.initMutableStates()} - } - - public java.lang.Object apply(java.lang.Object z) { - InternalRow ${ctx.INPUT_ROW} = (InternalRow) z; - ${eval.code} - return ${eval.isNull} ? ((Object)null) : ((Object)${eval.value}); - } - } - """ - - val code = CodeFormatter.stripOverlappingComments( - new CodeAndComment(codeBody, ctx.getPlaceHolderToComments())) - - val (clazz, _) = CodeGenerator.compile(code) - val codegen = clazz.generate(ctx.references.toArray).asInstanceOf[InternalRow => AnyRef] - - codegen(input) - } - - def dataType: DataType = encoder.catalystRepr - def children: Seq[Expression] = Nil - - override def genCode(ctx: CodegenContext): ExprCode = { - encoder.toCatalyst(new Literal(obj, encoder.jvmRepr)).genCode(ctx) - } - - protected def doGenCode(ctx: CodegenContext, ev: ExprCode): ExprCode = ??? -} diff --git a/dataset/src/main/scala/frameless/functions/NonAggregateFunctions.scala b/dataset/src/main/scala/frameless/functions/NonAggregateFunctions.scala deleted file mode 100644 index be5c66e8a..000000000 --- a/dataset/src/main/scala/frameless/functions/NonAggregateFunctions.scala +++ /dev/null @@ -1,803 +0,0 @@ -package frameless -package functions - -import org.apache.spark.sql.{Column, functions => sparkFunctions} - -import scala.util.matching.Regex - -trait NonAggregateFunctions { - /** Non-Aggregate function: calculates the SHA-2 digest of a binary column and returns the value as a 40 character hex string - * - * apache/spark - */ - def sha2[T](column: AbstractTypedColumn[T, Array[Byte]], numBits: Int): column.ThisType[T, String] = - column.typed(sparkFunctions.sha2(column.untyped, numBits)) - - /** Non-Aggregate function: calculates the SHA-1 digest of a binary column and returns the value as a 40 character hex string - * - * apache/spark - */ - def sha1[T](column: AbstractTypedColumn[T, Array[Byte]]): column.ThisType[T, String] = - column.typed(sparkFunctions.sha1(column.untyped)) - - /** Non-Aggregate function: returns a cyclic redundancy check value of a binary column as long. - * - * apache/spark - */ - def crc32[T](column: AbstractTypedColumn[T, Array[Byte]]): column.ThisType[T, Long] = - column.typed(sparkFunctions.crc32(column.untyped)) - /** - * Non-Aggregate function: returns the negated value of column. - * - * apache/spark - */ - def negate[A, B, T](column: AbstractTypedColumn[T,A])( - implicit i0: CatalystNumericWithJavaBigDecimal[A, B], - i1: TypedEncoder[B] - ): column.ThisType[T,B] = - column.typed(sparkFunctions.negate(column.untyped)) - - /** - * Non-Aggregate function: logical not. - * - * apache/spark - */ - def not[T](column: AbstractTypedColumn[T,Boolean]): column.ThisType[T,Boolean] = - column.typed(sparkFunctions.not(column.untyped)) - - /** - * Non-Aggregate function: Convert a number in a string column from one base to another. - * - * apache/spark - */ - def conv[T](column: AbstractTypedColumn[T,String], fromBase: Int, toBase: Int): column.ThisType[T,String] = - column.typed(sparkFunctions.conv(column.untyped,fromBase,toBase)) - - /** Non-Aggregate function: Converts an angle measured in radians to an approximately equivalent angle measured in degrees. - * - * apache/spark - */ - def degrees[A,T](column: AbstractTypedColumn[T,A]): column.ThisType[T,Double] = - column.typed(sparkFunctions.degrees(column.untyped)) - - /** Non-Aggregate function: returns the ceiling of a numeric column - * - * apache/spark - */ - def ceil[A, B, T](column: AbstractTypedColumn[T, A]) - (implicit - i0: CatalystRound[A, B], - i1: TypedEncoder[B] - ): column.ThisType[T, B] = - column.typed(sparkFunctions.ceil(column.untyped))(i1) - - /** Non-Aggregate function: returns the floor of a numeric column - * - * apache/spark - */ - def floor[A, B, T](column: AbstractTypedColumn[T, A]) - (implicit - i0: CatalystRound[A, B], - i1: TypedEncoder[B] - ): column.ThisType[T, B] = - column.typed(sparkFunctions.floor(column.untyped))(i1) - - /** Non-Aggregate function: unsigned shift the the given value numBits right. If given long, will return long else it will return an integer. - * - * apache/spark - */ - def shiftRightUnsigned[A, B, T](column: AbstractTypedColumn[T, A], numBits: Int) - (implicit - i0: CatalystBitShift[A, B], - i1: TypedEncoder[B] - ): column.ThisType[T, B] = - column.typed(sparkFunctions.shiftRightUnsigned(column.untyped, numBits)) - - /** Non-Aggregate function: shift the the given value numBits right. If given long, will return long else it will return an integer. - * - * apache/spark - */ - def shiftRight[A, B, T](column: AbstractTypedColumn[T, A], numBits: Int) - (implicit - i0: CatalystBitShift[A, B], - i1: TypedEncoder[B] - ): column.ThisType[T, B] = - column.typed(sparkFunctions.shiftRight(column.untyped, numBits)) - - /** Non-Aggregate function: shift the the given value numBits left. If given long, will return long else it will return an integer. - * - * apache/spark - */ - def shiftLeft[A, B, T](column: AbstractTypedColumn[T, A], numBits: Int) - (implicit - i0: CatalystBitShift[A, B], - i1: TypedEncoder[B] - ): column.ThisType[T, B] = - column.typed(sparkFunctions.shiftLeft(column.untyped, numBits)) - - /** Non-Aggregate function: returns the absolute value of a numeric column - * - * apache/spark - */ - def abs[A, B, T](column: AbstractTypedColumn[T, A]) - (implicit - i0: CatalystNumericWithJavaBigDecimal[A, B], - i1: TypedEncoder[B] - ): column.ThisType[T, B] = - column.typed(sparkFunctions.abs(column.untyped))(i1) - - /** Non-Aggregate function: Computes the cosine of the given value. - * - * Spark will expect a Double value for this expression. See: - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/mathExpressions.scala#L67]] - * apache/spark - */ - def cos[A, T](column: AbstractTypedColumn[T, A]) - (implicit i0: CatalystCast[A, Double]): column.ThisType[T, Double] = - column.typed(sparkFunctions.cos(column.cast[Double].untyped)) - - /** Non-Aggregate function: Computes the hyperbolic cosine of the given value. - * - * Spark will expect a Double value for this expression. See: - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/mathExpressions.scala#L67]] - * apache/spark - */ - def cosh[A, T](column: AbstractTypedColumn[T, A]) - (implicit i0: CatalystCast[A, Double]): column.ThisType[T, Double] = - column.typed(sparkFunctions.cosh(column.cast[Double].untyped)) - - /** Non-Aggregate function: Computes the signum of the given value. - * - * Spark will expect a Double value for this expression. See: - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/mathExpressions.scala#L67]] - * apache/spark - */ - def signum[A, T](column: AbstractTypedColumn[T, A]) - (implicit i0: CatalystCast[A, Double]): column.ThisType[T, Double] = - column.typed(sparkFunctions.signum(column.cast[Double].untyped)) - - /** Non-Aggregate function: Computes the sine of the given value. - * - * Spark will expect a Double value for this expression. See: - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/mathExpressions.scala#L67]] - * apache/spark - */ - def sin[A, T](column: AbstractTypedColumn[T, A]) - (implicit i0: CatalystCast[A, Double]): column.ThisType[T, Double] = - column.typed(sparkFunctions.sin(column.cast[Double].untyped)) - - /** Non-Aggregate function: Computes the hyperbolic sine of the given value. - * - * Spark will expect a Double value for this expression. See: - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/mathExpressions.scala#L67]] - * apache/spark - */ - def sinh[A, T](column: AbstractTypedColumn[T, A]) - (implicit i0: CatalystCast[A, Double]): column.ThisType[T, Double] = - column.typed(sparkFunctions.sinh(column.cast[Double].untyped)) - - /** Non-Aggregate function: Computes the tangent of the given column. - * - * Spark will expect a Double value for this expression. See: - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/mathExpressions.scala#L67]] - * apache/spark - */ - def tan[A, T](column: AbstractTypedColumn[T, A]) - (implicit i0: CatalystCast[A, Double]): column.ThisType[T, Double] = - column.typed(sparkFunctions.tan(column.cast[Double].untyped)) - - /** Non-Aggregate function: Computes the hyperbolic tangent of the given value. - * - * Spark will expect a Double value for this expression. See: - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/mathExpressions.scala#L67]] - * apache/spark - */ - def tanh[A, T](column: AbstractTypedColumn[T, A]) - (implicit i0: CatalystCast[A, Double]): column.ThisType[T, Double] = - column.typed(sparkFunctions.tanh(column.cast[Double].untyped)) - - /** Non-Aggregate function: returns the acos of a numeric column - * - * Spark will expect a Double value for this expression. See: - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/mathExpressions.scala#L67]] - * apache/spark - */ - def acos[A, T](column: AbstractTypedColumn[T, A]) - (implicit i0: CatalystCast[A, Double]): column.ThisType[T, Double] = - column.typed(sparkFunctions.acos(column.cast[Double].untyped)) - - /** Non-Aggregate function: returns true if value is contained with in the array in the specified column - * - * apache/spark - */ - def arrayContains[C[_]: CatalystCollection, A, T](column: AbstractTypedColumn[T, C[A]], value: A): column.ThisType[T, Boolean] = - column.typed(sparkFunctions.array_contains(column.untyped, value)) - - /** Non-Aggregate function: returns the atan of a numeric column - * - * Spark will expect a Double value for this expression. See: - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/mathExpressions.scala#L67]] - * apache/spark - */ - def atan[A, T](column: AbstractTypedColumn[T,A]) - (implicit i0: CatalystCast[A, Double]): column.ThisType[T, Double] = - column.typed(sparkFunctions.atan(column.cast[Double].untyped)) - - /** Non-Aggregate function: returns the asin of a numeric column - * - * Spark will expect a Double value for this expression. See: - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/mathExpressions.scala#L67]] - * apache/spark - */ - def asin[A, T](column: AbstractTypedColumn[T, A]) - (implicit i0: CatalystCast[A, Double]): column.ThisType[T, Double] = - column.typed(sparkFunctions.asin(column.cast[Double].untyped)) - - /** Non-Aggregate function: returns the angle theta from the conversion of rectangular coordinates (x, y) to - * polar coordinates (r, theta). - * - * Spark will expect a Double value for this expression. See: - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/mathExpressions.scala#L67]] - * apache/spark - */ - def atan2[A, B, T](l: TypedColumn[T, A], r: TypedColumn[T, B]) - (implicit - i0: CatalystCast[A, Double], - i1: CatalystCast[B, Double] - ): TypedColumn[T, Double] = - r.typed(sparkFunctions.atan2(l.cast[Double].untyped, r.cast[Double].untyped)) - - /** Non-Aggregate function: returns the angle theta from the conversion of rectangular coordinates (x, y) to - * polar coordinates (r, theta). - * - * Spark will expect a Double value for this expression. See: - * [[https://github.com/apache/spark/blob/4a3c09601ba69f7d49d1946bb6f20f5cfe453031/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/mathExpressions.scala#L67]] - * apache/spark - */ - def atan2[A, B, T](l: TypedAggregate[T, A], r: TypedAggregate[T, B]) - (implicit - i0: CatalystCast[A, Double], - i1: CatalystCast[B, Double] - ): TypedAggregate[T, Double] = - r.typed(sparkFunctions.atan2(l.cast[Double].untyped, r.cast[Double].untyped)) - - def atan2[B, T](l: Double, r: TypedColumn[T, B]) - (implicit i0: CatalystCast[B, Double]): TypedColumn[T, Double] = - atan2(r.lit(l), r) - - def atan2[A, T](l: TypedColumn[T, A], r: Double) - (implicit i0: CatalystCast[A, Double]): TypedColumn[T, Double] = - atan2(l, l.lit(r)) - - def atan2[B, T](l: Double, r: TypedAggregate[T, B]) - (implicit i0: CatalystCast[B, Double]): TypedAggregate[T, Double] = - atan2(r.lit(l), r) - - def atan2[A, T](l: TypedAggregate[T, A], r: Double) - (implicit i0: CatalystCast[A, Double]): TypedAggregate[T, Double] = - atan2(l, l.lit(r)) - - /** Non-Aggregate function: returns the square root value of a numeric column. - * - * apache/spark - */ - def sqrt[A, T](column: AbstractTypedColumn[T, A]) - (implicit i0: CatalystCast[A, Double]): column.ThisType[T, Double] = - column.typed(sparkFunctions.sqrt(column.cast[Double].untyped)) - - /** Non-Aggregate function: returns the cubic root value of a numeric column. - * - * apache/spark - */ - def cbrt[A, T](column: AbstractTypedColumn[T, A]) - (implicit i0: CatalystCast[A, Double]): column.ThisType[T, Double] = - column.typed(sparkFunctions.cbrt(column.cast[Double].untyped)) - - /** Non-Aggregate function: returns the exponential value of a numeric column. - * - * apache/spark - */ - def exp[A, T](column: AbstractTypedColumn[T, A]) - (implicit i0: CatalystCast[A, Double]): column.ThisType[T, Double] = - column.typed(sparkFunctions.exp(column.cast[Double].untyped)) - - /** Non-Aggregate function: Returns the value of the column `e` rounded to 0 decimal places with HALF_UP round mode. - * - * apache/spark - */ - def round[A, B, T](column: AbstractTypedColumn[T, A])( - implicit i0: CatalystNumericWithJavaBigDecimal[A, B], i1: TypedEncoder[B] - ): column.ThisType[T, B] = - column.typed(sparkFunctions.round(column.untyped))(i1) - - /** Non-Aggregate function: Round the value of `e` to `scale` decimal places with HALF_UP round mode - * if `scale` is greater than or equal to 0 or at integral part when `scale` is less than 0. - * - * apache/spark - */ - def round[A, B, T](column: AbstractTypedColumn[T, A], scale: Int)( - implicit i0: CatalystNumericWithJavaBigDecimal[A, B], i1: TypedEncoder[B] - ): column.ThisType[T, B] = - column.typed(sparkFunctions.round(column.untyped, scale))(i1) - - /** Non-Aggregate function: Bankers Rounding - returns the rounded to 0 decimal places value with HALF_EVEN round mode - * of a numeric column. - * - * apache/spark - */ - def bround[A, B, T](column: AbstractTypedColumn[T, A])( - implicit i0: CatalystNumericWithJavaBigDecimal[A, B], i1: TypedEncoder[B] - ): column.ThisType[T, B] = - column.typed(sparkFunctions.bround(column.untyped))(i1) - - /** Non-Aggregate function: Bankers Rounding - returns the rounded to `scale` decimal places value with HALF_EVEN round mode - * of a numeric column. If `scale` is greater than or equal to 0 or at integral part when `scale` is less than 0. - * - * apache/spark - */ - def bround[A, B, T](column: AbstractTypedColumn[T, A], scale: Int)( - implicit i0: CatalystNumericWithJavaBigDecimal[A, B], i1: TypedEncoder[B] - ): column.ThisType[T, B] = - column.typed(sparkFunctions.bround(column.untyped, scale))(i1) - - /** - * Computes the natural logarithm of the given value. - * - * apache/spark - */ - def log[A, T](column: AbstractTypedColumn[T, A])( - implicit i0: CatalystCast[A, Double] - ): column.ThisType[T, Double] = - column.typed(sparkFunctions.log(column.untyped)) - - /** - * Returns the first argument-base logarithm of the second argument. - * - * apache/spark - */ - def log[A, T](base: Double, column: AbstractTypedColumn[T, A])( - implicit i0: CatalystCast[A, Double] - ): column.ThisType[T, Double] = - column.typed(sparkFunctions.log(base, column.untyped)) - - /** - * Computes the logarithm of the given column in base 2. - * - * apache/spark - */ - def log2[A, T](column: AbstractTypedColumn[T, A])( - implicit i0: CatalystCast[A, Double] - ): column.ThisType[T, Double] = - column.typed(sparkFunctions.log2(column.untyped)) - - /** - * Computes the natural logarithm of the given value plus one. - * - * apache/spark - */ - def log1p[A, T](column: AbstractTypedColumn[T, A])( - implicit i0: CatalystCast[A, Double] - ): column.ThisType[T, Double] = - column.typed(sparkFunctions.log1p(column.untyped)) - - /** - * Computes the logarithm of the given column in base 10. - * - * apache/spark - */ - def log10[A, T](column: AbstractTypedColumn[T, A])( - implicit i0: CatalystCast[A, Double] - ): column.ThisType[T, Double] = - column.typed(sparkFunctions.log10(column.untyped)) - - - /** - * Computes `sqrt(a^2^ + b^2^)` without intermediate overflow or underflow. - * - * apache/spark - */ - def hypot[A, T](column: AbstractTypedColumn[T, A], column2: AbstractTypedColumn[T, A])( - implicit i0: CatalystCast[A, Double] - ): column.ThisType[T, Double] = - column.typed(sparkFunctions.hypot(column.untyped, column2.untyped)) - - /** - * Computes `sqrt(a^2^ + b^2^)` without intermediate overflow or underflow. - * - * apache/spark - */ - def hypot[A, T](column: AbstractTypedColumn[T, A], l: Double)( - implicit i0: CatalystCast[A, Double] - ): column.ThisType[T, Double] = - column.typed(sparkFunctions.hypot(column.untyped, l)) - - /** - * Computes `sqrt(a^2^ + b^2^)` without intermediate overflow or underflow. - * - * apache/spark - */ - def hypot[A, T](l: Double, column: AbstractTypedColumn[T, A])( - implicit i0: CatalystCast[A, Double] - ): column.ThisType[T, Double] = - column.typed(sparkFunctions.hypot(l, column.untyped)) - - /** - * Returns the value of the first argument raised to the power of the second argument. - * - * apache/spark - */ - def pow[A, T](column: AbstractTypedColumn[T, A], column2: AbstractTypedColumn[T, A])( - implicit i0: CatalystCast[A, Double] - ): column.ThisType[T, Double] = - column.typed(sparkFunctions.pow(column.untyped, column2.untyped)) - - /** - * Returns the value of the first argument raised to the power of the second argument. - * - * apache/spark - */ - def pow[A, T](column: AbstractTypedColumn[T, A], l: Double)( - implicit i0: CatalystCast[A, Double] - ): column.ThisType[T, Double] = - column.typed(sparkFunctions.pow(column.untyped, l)) - - /** - * Returns the value of the first argument raised to the power of the second argument. - * - * apache/spark - */ - def pow[A, T](l: Double, column: AbstractTypedColumn[T, A])( - implicit i0: CatalystCast[A, Double] - ): column.ThisType[T, Double] = - column.typed(sparkFunctions.pow(l, column.untyped)) - - /** - * Returns the positive value of dividend mod divisor. - * - * apache/spark - */ - def pmod[A, T](column: AbstractTypedColumn[T, A], column2: AbstractTypedColumn[T, A])( - implicit i0: TypedEncoder[A] - ): column.ThisType[T, A] = - column.typed(sparkFunctions.pmod(column.untyped, column2.untyped)) - - - /** Non-Aggregate function: Returns the string representation of the binary value of the given long - * column. For example, bin("12") returns "1100". - * - * apache/spark - */ - def bin[T](column: AbstractTypedColumn[T, Long]): column.ThisType[T, String] = - column.typed(sparkFunctions.bin(column.untyped)) - - /** - * Calculates the MD5 digest of a binary column and returns the value - * as a 32 character hex string. - * - * apache/spark - */ - def md5[T, A](column: AbstractTypedColumn[T, A])(implicit i0: TypedEncoder[A]): column.ThisType[T, String] = - column.typed(sparkFunctions.md5(column.untyped)) - - /** - * Computes the factorial of the given value. - * - * apache/spark - */ - def factorial[T](column: AbstractTypedColumn[T, Long])(implicit i0: TypedEncoder[Long]): column.ThisType[T, Long] = - column.typed(sparkFunctions.factorial(column.untyped)) - - /** Non-Aggregate function: Computes bitwise NOT. - * - * apache/spark - */ - def bitwiseNOT[A: CatalystBitwise, T](column: AbstractTypedColumn[T, A]): column.ThisType[T, A] = - column.typed(sparkFunctions.bitwiseNOT(column.untyped))(column.uencoder) - - /** Non-Aggregate function: file name of the current Spark task. Empty string if row did not originate from - * a file - * - * apache/spark - */ - def inputFileName[T](): TypedColumn[T, String] = { - new TypedColumn[T, String](sparkFunctions.input_file_name()) - } - - /** Non-Aggregate function: generates monotonically increasing id - * - * apache/spark - */ - def monotonicallyIncreasingId[T](): TypedColumn[T, Long] = { - new TypedColumn[T, Long](sparkFunctions.monotonically_increasing_id()) - } - - /** Non-Aggregate function: Evaluates a list of conditions and returns one of multiple - * possible result expressions. If none match, otherwise is returned - * {{{ - * when(ds('boolField), ds('a)) - * .when(ds('otherBoolField), lit(123)) - * .otherwise(ds('b)) - * }}} - * apache/spark - */ - def when[T, A](condition: AbstractTypedColumn[T, Boolean], value: AbstractTypedColumn[T, A]): When[T, A] = - new When[T, A](condition, value) - - class When[T, A] private (untypedC: Column) { - private[functions] def this(condition: AbstractTypedColumn[T, Boolean], value: AbstractTypedColumn[T, A]) = - this(sparkFunctions.when(condition.untyped, value.untyped)) - - def when(condition: AbstractTypedColumn[T, Boolean], value: AbstractTypedColumn[T, A]): When[T, A] = - new When[T, A](untypedC.when(condition.untyped, value.untyped)) - - def otherwise(value: AbstractTypedColumn[T, A]): value.ThisType[T, A] = - value.typed(untypedC.otherwise(value.untyped))(value.uencoder) - } - - ////////////////////////////////////////////////////////////////////////////////////////////// - // String functions - ////////////////////////////////////////////////////////////////////////////////////////////// - - - /** Non-Aggregate function: takes the first letter of a string column and returns the ascii int value in a new column - * - * apache/spark - */ - def ascii[T](column: AbstractTypedColumn[T, String]): column.ThisType[T, Int] = - column.typed(sparkFunctions.ascii(column.untyped)) - - /** Non-Aggregate function: Computes the BASE64 encoding of a binary column and returns it as a string column. - * This is the reverse of unbase64. - * - * apache/spark - */ - def base64[T](column: AbstractTypedColumn[T, Array[Byte]]): column.ThisType[T, String] = - column.typed(sparkFunctions.base64(column.untyped)) - - /** Non-Aggregate function: Decodes a BASE64 encoded string column and returns it as a binary column. - * This is the reverse of base64. - * - * apache/spark - */ - def unbase64[T](column: AbstractTypedColumn[T, String]): column.ThisType[T, Array[Byte]] = - column.typed(sparkFunctions.unbase64(column.untyped)) - - /** Non-Aggregate function: Concatenates multiple input string columns together into a single string column. - * @note varargs make it harder to generalize so we overload the method for [[TypedColumn]] and [[TypedAggregate]] - * - * apache/spark - */ - def concat[T](columns: TypedColumn[T, String]*): TypedColumn[T, String] = - new TypedColumn(sparkFunctions.concat(columns.map(_.untyped): _*)) - - /** Non-Aggregate function: Concatenates multiple input string columns together into a single string column. - * @note varargs make it harder to generalize so we overload the method for [[TypedColumn]] and [[TypedAggregate]] - * - * apache/spark - */ - def concat[T](columns: TypedAggregate[T, String]*): TypedAggregate[T, String] = - new TypedAggregate(sparkFunctions.concat(columns.map(_.untyped): _*)) - - /** Non-Aggregate function: Concatenates multiple input string columns together into a single string column, - * using the given separator. - * @note varargs make it harder to generalize so we overload the method for [[TypedColumn]] and [[TypedAggregate]] - * - * apache/spark - */ - def concatWs[T](sep: String, columns: TypedAggregate[T, String]*): TypedAggregate[T, String] = - new TypedAggregate(sparkFunctions.concat_ws(sep, columns.map(_.untyped): _*)) - - /** Non-Aggregate function: Concatenates multiple input string columns together into a single string column, - * using the given separator. - * @note varargs make it harder to generalize so we overload the method for [[TypedColumn]] and [[TypedAggregate]] - * - * apache/spark - */ - def concatWs[T](sep: String, columns: TypedColumn[T, String]*): TypedColumn[T, String] = - new TypedColumn(sparkFunctions.concat_ws(sep, columns.map(_.untyped): _*)) - - /** Non-Aggregate function: Locates the position of the first occurrence of substring column - * in given string - * - * @note The position is not zero based, but 1 based index. Returns 0 if substr - * could not be found in str. - * - * apache/spark - */ - def instr[T](str: AbstractTypedColumn[T, String], substring: String): str.ThisType[T, Int] = - str.typed(sparkFunctions.instr(str.untyped, substring)) - - /** Non-Aggregate function: Computes the length of a given string. - * - * apache/spark - */ - //TODO: Also for binary - def length[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, Int] = - str.typed(sparkFunctions.length(str.untyped)) - - /** Non-Aggregate function: Computes the Levenshtein distance of the two given string columns. - * - * apache/spark - */ - def levenshtein[T](l: TypedColumn[T, String], r: TypedColumn[T, String]): TypedColumn[T, Int] = - l.typed(sparkFunctions.levenshtein(l.untyped, r.untyped)) - - /** Non-Aggregate function: Computes the Levenshtein distance of the two given string columns. - * - * apache/spark - */ - def levenshtein[T](l: TypedAggregate[T, String], r: TypedAggregate[T, String]): TypedAggregate[T, Int] = - l.typed(sparkFunctions.levenshtein(l.untyped, r.untyped)) - - /** Non-Aggregate function: Converts a string column to lower case. - * - * apache/spark - */ - def lower[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, String] = - str.typed(sparkFunctions.lower(str.untyped)) - - /** Non-Aggregate function: Left-pad the string column with pad to a length of len. If the string column is longer - * than len, the return value is shortened to len characters. - * - * apache/spark - */ - def lpad[T](str: AbstractTypedColumn[T, String], - len: Int, - pad: String): str.ThisType[T, String] = - str.typed(sparkFunctions.lpad(str.untyped, len, pad)) - - /** Non-Aggregate function: Trim the spaces from left end for the specified string value. - * - * apache/spark - */ - def ltrim[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, String] = - str.typed(sparkFunctions.ltrim(str.untyped)) - - /** Non-Aggregate function: Replace all substrings of the specified string value that match regexp with rep. - * - * apache/spark - */ - def regexpReplace[T](str: AbstractTypedColumn[T, String], - pattern: Regex, - replacement: String): str.ThisType[T, String] = - str.typed(sparkFunctions.regexp_replace(str.untyped, pattern.regex, replacement)) - - - /** Non-Aggregate function: Reverses the string column and returns it as a new string column. - * - * apache/spark - */ - def reverse[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, String] = - str.typed(sparkFunctions.reverse(str.untyped)) - - /** Non-Aggregate function: Right-pad the string column with pad to a length of len. - * If the string column is longer than len, the return value is shortened to len characters. - * - * apache/spark - */ - def rpad[T](str: AbstractTypedColumn[T, String], len: Int, pad: String): str.ThisType[T, String] = - str.typed(sparkFunctions.rpad(str.untyped, len, pad)) - - /** Non-Aggregate function: Trim the spaces from right end for the specified string value. - * - * apache/spark - */ - def rtrim[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, String] = - str.typed(sparkFunctions.rtrim(str.untyped)) - - /** Non-Aggregate function: Substring starts at `pos` and is of length `len` - * - * apache/spark - */ - //TODO: Also for byte array - def substring[T](str: AbstractTypedColumn[T, String], pos: Int, len: Int): str.ThisType[T, String] = - str.typed(sparkFunctions.substring(str.untyped, pos, len)) - - /** Non-Aggregate function: Trim the spaces from both ends for the specified string column. - * - * apache/spark - */ - def trim[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, String] = - str.typed(sparkFunctions.trim(str.untyped)) - - /** Non-Aggregate function: Converts a string column to upper case. - * - * apache/spark - */ - def upper[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, String] = - str.typed(sparkFunctions.upper(str.untyped)) - - ////////////////////////////////////////////////////////////////////////////////////////////// - // DateTime functions - ////////////////////////////////////////////////////////////////////////////////////////////// - - /** Non-Aggregate function: Extracts the year as an integer from a given date/timestamp/string. - * - * Differs from `Column#year` by wrapping it's result into an `Option`. - * - * apache/spark - */ - def year[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, Option[Int]] = - str.typed(sparkFunctions.year(str.untyped)) - - /** Non-Aggregate function: Extracts the quarter as an integer from a given date/timestamp/string. - * - * Differs from `Column#quarter` by wrapping it's result into an `Option`. - * - * apache/spark - */ - def quarter[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, Option[Int]] = - str.typed(sparkFunctions.quarter(str.untyped)) - - /** Non-Aggregate function Extracts the month as an integer from a given date/timestamp/string. - * - * Differs from `Column#month` by wrapping it's result into an `Option`. - * - * apache/spark - */ - def month[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, Option[Int]] = - str.typed(sparkFunctions.month(str.untyped)) - - /** Non-Aggregate function: Extracts the day of the week as an integer from a given date/timestamp/string. - * - * Differs from `Column#dayofweek` by wrapping it's result into an `Option`. - * - * apache/spark - */ - def dayofweek[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, Option[Int]] = - str.typed(sparkFunctions.dayofweek(str.untyped)) - - /** Non-Aggregate function: Extracts the day of the month as an integer from a given date/timestamp/string. - * - * Differs from `Column#dayofmonth` by wrapping it's result into an `Option`. - * - * apache/spark - */ - def dayofmonth[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, Option[Int]] = - str.typed(sparkFunctions.dayofmonth(str.untyped)) - - /** Non-Aggregate function: Extracts the day of the year as an integer from a given date/timestamp/string. - * - * Differs from `Column#dayofyear` by wrapping it's result into an `Option`. - * - * apache/spark - */ - def dayofyear[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, Option[Int]] = - str.typed(sparkFunctions.dayofyear(str.untyped)) - - /** Non-Aggregate function: Extracts the hours as an integer from a given date/timestamp/string. - * - * Differs from `Column#hour` by wrapping it's result into an `Option`. - * - * apache/spark - */ - def hour[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, Option[Int]] = - str.typed(sparkFunctions.hour(str.untyped)) - - /** Non-Aggregate function: Extracts the minutes as an integer from a given date/timestamp/string. - * - * Differs from `Column#minute` by wrapping it's result into an `Option`. - * - * apache/spark - */ - def minute[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, Option[Int]] = - str.typed(sparkFunctions.minute(str.untyped)) - - /** Non-Aggregate function: Extracts the seconds as an integer from a given date/timestamp/string. - * - * Differs from `Column#second` by wrapping it's result into an `Option`. - * - * apache/spark - */ - def second[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, Option[Int]] = - str.typed(sparkFunctions.second(str.untyped)) - - /** Non-Aggregate function: Extracts the week number as an integer from a given date/timestamp/string. - * - * Differs from `Column#weekofyear` by wrapping it's result into an `Option`. - * - * apache/spark - */ - def weekofyear[T](str: AbstractTypedColumn[T, String]): str.ThisType[T, Option[Int]] = - str.typed(sparkFunctions.weekofyear(str.untyped)) -} diff --git a/dataset/src/main/scala/frameless/functions/Udf.scala b/dataset/src/main/scala/frameless/functions/Udf.scala deleted file mode 100644 index 4294933f2..000000000 --- a/dataset/src/main/scala/frameless/functions/Udf.scala +++ /dev/null @@ -1,224 +0,0 @@ -package frameless -package functions - -import org.apache.spark.sql.catalyst.InternalRow -import org.apache.spark.sql.catalyst.expressions.{Expression, LeafExpression, NonSQLExpression} -import org.apache.spark.sql.catalyst.expressions.codegen._ -import Block._ -import org.apache.spark.sql.types.DataType -import shapeless.syntax.std.tuple._ - -/** Documentation marked "apache/spark" is thanks to apache/spark Contributors - * at https://github.com/apache/spark, licensed under Apache v2.0 available at - * http://www.apache.org/licenses/LICENSE-2.0 - */ -trait Udf { - - /** Defines a user-defined function of 1 arguments as user-defined function (UDF). - * The data types are automatically inferred based on the function's signature. - * - * apache/spark - */ - def udf[T, A, R: TypedEncoder](f: A => R): - TypedColumn[T, A] => TypedColumn[T, R] = { - u => - val scalaUdf = FramelessUdf(f, List(u), TypedEncoder[R]) - new TypedColumn[T, R](scalaUdf) - } - - /** Defines a user-defined function of 2 arguments as user-defined function (UDF). - * The data types are automatically inferred based on the function's signature. - * - * apache/spark - */ - def udf[T, A1, A2, R: TypedEncoder](f: (A1,A2) => R): - (TypedColumn[T, A1], TypedColumn[T, A2]) => TypedColumn[T, R] = { - case us => - val scalaUdf = FramelessUdf(f, us.toList[UntypedExpression[T]], TypedEncoder[R]) - new TypedColumn[T, R](scalaUdf) - } - - /** Defines a user-defined function of 3 arguments as user-defined function (UDF). - * The data types are automatically inferred based on the function's signature. - * - * apache/spark - */ - def udf[T, A1, A2, A3, R: TypedEncoder](f: (A1,A2,A3) => R): - (TypedColumn[T, A1], TypedColumn[T, A2], TypedColumn[T, A3]) => TypedColumn[T, R] = { - case us => - val scalaUdf = FramelessUdf(f, us.toList[UntypedExpression[T]], TypedEncoder[R]) - new TypedColumn[T, R](scalaUdf) - } - - /** Defines a user-defined function of 4 arguments as user-defined function (UDF). - * The data types are automatically inferred based on the function's signature. - * - * apache/spark - */ - def udf[T, A1, A2, A3, A4, R: TypedEncoder](f: (A1,A2,A3,A4) => R): - (TypedColumn[T, A1], TypedColumn[T, A2], TypedColumn[T, A3], TypedColumn[T, A4]) => TypedColumn[T, R] = { - case us => - val scalaUdf = FramelessUdf(f, us.toList[UntypedExpression[T]], TypedEncoder[R]) - new TypedColumn[T, R](scalaUdf) - } - - /** Defines a user-defined function of 5 arguments as user-defined function (UDF). - * The data types are automatically inferred based on the function's signature. - * - * apache/spark - */ - def udf[T, A1, A2, A3, A4, A5, R: TypedEncoder](f: (A1,A2,A3,A4,A5) => R): - (TypedColumn[T, A1], TypedColumn[T, A2], TypedColumn[T, A3], TypedColumn[T, A4], TypedColumn[T, A5]) => TypedColumn[T, R] = { - case us => - val scalaUdf = FramelessUdf(f, us.toList[UntypedExpression[T]], TypedEncoder[R]) - new TypedColumn[T, R](scalaUdf) - } -} - -/** - * NB: Implementation detail, isn't intended to be directly used. - * - * Our own implementation of `ScalaUDF` from Catalyst compatible with [[TypedEncoder]]. - */ -case class FramelessUdf[T, R]( - function: AnyRef, - encoders: Seq[TypedEncoder[_]], - children: Seq[Expression], - rencoder: TypedEncoder[R] -) extends Expression with NonSQLExpression { - - override def nullable: Boolean = rencoder.nullable - override def toString: String = s"FramelessUdf(${children.mkString(", ")})" - - lazy val evalCode = { - val ctx = new CodegenContext() - val eval = genCode(ctx) - - val codeBody = s""" - public scala.Function1 generate(Object[] references) { - return new FramelessUdfEvalImpl(references); - } - - class FramelessUdfEvalImpl extends scala.runtime.AbstractFunction1 { - private final Object[] references; - ${ctx.declareMutableStates()} - ${ctx.declareAddedFunctions()} - - public FramelessUdfEvalImpl(Object[] references) { - this.references = references; - ${ctx.initMutableStates()} - } - - public java.lang.Object apply(java.lang.Object z) { - InternalRow ${ctx.INPUT_ROW} = (InternalRow) z; - ${eval.code} - return ${eval.isNull} ? ((Object)null) : ((Object)${eval.value}); - } - } - """ - - val code = CodeFormatter.stripOverlappingComments( - new CodeAndComment(codeBody, ctx.getPlaceHolderToComments())) - - val (clazz, _) = CodeGenerator.compile(code) - val codegen = clazz.generate(ctx.references.toArray).asInstanceOf[InternalRow => AnyRef] - - codegen - } - - def eval(input: InternalRow): Any = { - evalCode(input) - } - - def dataType: DataType = rencoder.catalystRepr - - override def doGenCode(ctx: CodegenContext, ev: ExprCode): ExprCode = { - ctx.references += this - - // save reference to `function` field from `FramelessUdf` to call it later - val framelessUdfClassName = classOf[FramelessUdf[_, _]].getName - val funcClassName = s"scala.Function${children.size}" - val funcExpressionIdx = ctx.references.size - 1 - val funcTerm = ctx.addMutableState(funcClassName, ctx.freshName("udf"), - v => s"$v = ($funcClassName)((($framelessUdfClassName)references" + - s"[$funcExpressionIdx]).function());") - - val (argsCode, funcArguments) = encoders.zip(children).map { - case (encoder, child) => - val eval = child.genCode(ctx) - val codeTpe = CodeGenerator.boxedType(encoder.jvmRepr) - val argTerm = ctx.freshName("arg") - val convert = s"${eval.code}\n$codeTpe $argTerm = ${eval.isNull} ? (($codeTpe)null) : (($codeTpe)(${eval.value}));" - - (convert, argTerm) - }.unzip - - val internalTpe = CodeGenerator.boxedType(rencoder.jvmRepr) - val internalTerm = ctx.addMutableState(internalTpe, ctx.freshName("internal")) - val internalNullTerm = ctx.addMutableState("boolean", ctx.freshName("internalNull")) - // CTw - can't inject the term, may have to duplicate old code for parity - val internalExpr = Spark2_4_LambdaVariable(internalTerm, internalNullTerm, rencoder.jvmRepr, true) - - val resultEval = rencoder.toCatalyst(internalExpr).genCode(ctx) - - ev.copy(code = code""" - ${argsCode.mkString("\n")} - - $internalTerm = - ($internalTpe)$funcTerm.apply(${funcArguments.mkString(", ")}); - $internalNullTerm = $internalTerm == null; - - ${resultEval.code} - """, - value = resultEval.value, - isNull = resultEval.isNull - ) - } -} - -case class Spark2_4_LambdaVariable( - value: String, - isNull: String, - dataType: DataType, - nullable: Boolean = true) extends LeafExpression with NonSQLExpression { - - private val accessor: (InternalRow, Int) => Any = InternalRow.getAccessor(dataType) - - // Interpreted execution of `LambdaVariable` always get the 0-index element from input row. - override def eval(input: InternalRow): Any = { - assert(input.numFields == 1, - "The input row of interpreted LambdaVariable should have only 1 field.") - if (nullable && input.isNullAt(0)) { - null - } else { - accessor(input, 0) - } - } - - override def genCode(ctx: CodegenContext): ExprCode = { - val isNullValue = if (nullable) { - JavaCode.isNullVariable(isNull) - } else { - FalseLiteral - } - ExprCode(value = JavaCode.variable(value, dataType), isNull = isNullValue) - } - - // This won't be called as `genCode` is overrided, just overriding it to make - // `LambdaVariable` non-abstract. - override protected def doGenCode(ctx: CodegenContext, ev: ExprCode): ExprCode = ev -} - -object FramelessUdf { - // Spark needs case class with `children` field to mutate it - def apply[T, R]( - function: AnyRef, - cols: Seq[UntypedExpression[T]], - rencoder: TypedEncoder[R] - ): FramelessUdf[T, R] = FramelessUdf( - function = function, - encoders = cols.map(_.uencoder).toList, - children = cols.map(x => x.uencoder.fromCatalyst(x.expr)).toList, - rencoder = rencoder - ) -} diff --git a/dataset/src/main/scala/frameless/functions/UnaryFunctions.scala b/dataset/src/main/scala/frameless/functions/UnaryFunctions.scala deleted file mode 100644 index 64bdf0ed1..000000000 --- a/dataset/src/main/scala/frameless/functions/UnaryFunctions.scala +++ /dev/null @@ -1,95 +0,0 @@ -package frameless -package functions - -import org.apache.spark.sql.{Column, functions => sparkFunctions} - -import scala.math.Ordering - -trait UnaryFunctions { - /** Returns length of array - * - * apache/spark - */ - def size[T, A, V[_] : CatalystSizableCollection](column: TypedColumn[T, V[A]]): TypedColumn[T, Int] = - new TypedColumn[T, Int](implicitly[CatalystSizableCollection[V]].sizeOp(column.untyped)) - - /** Returns length of Map - * - * apache/spark - */ - def size[T, A, B](column: TypedColumn[T, Map[A, B]]): TypedColumn[T, Int] = - new TypedColumn[T, Int](sparkFunctions.size(column.untyped)) - - /** Sorts the input array for the given column in ascending order, according to - * the natural ordering of the array elements. - * - * apache/spark - */ - def sortAscending[T, A: Ordering, V[_] : CatalystSortableCollection](column: TypedColumn[T, V[A]]): TypedColumn[T, V[A]] = - new TypedColumn[T, V[A]](implicitly[CatalystSortableCollection[V]].sortOp(column.untyped, sortAscending = true))(column.uencoder) - - /** Sorts the input array for the given column in descending order, according to - * the natural ordering of the array elements. - * - * apache/spark - */ - def sortDescending[T, A: Ordering, V[_] : CatalystSortableCollection](column: TypedColumn[T, V[A]]): TypedColumn[T, V[A]] = - new TypedColumn[T, V[A]](implicitly[CatalystSortableCollection[V]].sortOp(column.untyped, sortAscending = false))(column.uencoder) - - - /** Creates a new row for each element in the given collection. The column types - * eligible for this operation are constrained by CatalystExplodableCollection. - * - * apache/spark - */ - @deprecated("Use explode() from the TypedDataset instead. This method will result in " + - "runtime error if applied to two columns in the same select statement.", "0.6.2") - def explode[T, A: TypedEncoder, V[_] : CatalystExplodableCollection](column: TypedColumn[T, V[A]]): TypedColumn[T, A] = - new TypedColumn[T, A](sparkFunctions.explode(column.untyped)) -} - -trait CatalystSizableCollection[V[_]] { - def sizeOp(col: Column): Column -} - -object CatalystSizableCollection { - implicit def sizableVector: CatalystSizableCollection[Vector] = new CatalystSizableCollection[Vector] { - def sizeOp(col: Column): Column = sparkFunctions.size(col) - } - - implicit def sizableArray: CatalystSizableCollection[Array] = new CatalystSizableCollection[Array] { - def sizeOp(col: Column): Column = sparkFunctions.size(col) - } - - implicit def sizableList: CatalystSizableCollection[List] = new CatalystSizableCollection[List] { - def sizeOp(col: Column): Column = sparkFunctions.size(col) - } - -} - -trait CatalystExplodableCollection[V[_]] - -object CatalystExplodableCollection { - implicit def explodableVector: CatalystExplodableCollection[Vector] = new CatalystExplodableCollection[Vector] {} - implicit def explodableArray: CatalystExplodableCollection[Array] = new CatalystExplodableCollection[Array] {} - implicit def explodableList: CatalystExplodableCollection[List] = new CatalystExplodableCollection[List] {} - implicit def explodableSeq: CatalystExplodableCollection[Seq] = new CatalystExplodableCollection[Seq] {} -} - -trait CatalystSortableCollection[V[_]] { - def sortOp(col: Column, sortAscending: Boolean): Column -} - -object CatalystSortableCollection { - implicit def sortableVector: CatalystSortableCollection[Vector] = new CatalystSortableCollection[Vector] { - def sortOp(col: Column, sortAscending: Boolean): Column = sparkFunctions.sort_array(col, sortAscending) - } - - implicit def sortableArray: CatalystSortableCollection[Array] = new CatalystSortableCollection[Array] { - def sortOp(col: Column, sortAscending: Boolean): Column = sparkFunctions.sort_array(col, sortAscending) - } - - implicit def sortableList: CatalystSortableCollection[List] = new CatalystSortableCollection[List] { - def sortOp(col: Column, sortAscending: Boolean): Column = sparkFunctions.sort_array(col, sortAscending) - } -} diff --git a/dataset/src/main/scala/frameless/functions/package.scala b/dataset/src/main/scala/frameless/functions/package.scala deleted file mode 100644 index f1e72a0e6..000000000 --- a/dataset/src/main/scala/frameless/functions/package.scala +++ /dev/null @@ -1,35 +0,0 @@ -package frameless - -import org.apache.spark.sql.catalyst.ScalaReflection -import org.apache.spark.sql.catalyst.expressions.Literal - -package object functions extends Udf with UnaryFunctions { - object aggregate extends AggregateFunctions - object nonAggregate extends NonAggregateFunctions - - /** Creates a [[frameless.TypedAggregate]] of literal value. If A is to be encoded using an Injection make - * sure the injection instance is in scope. - * - * apache/spark - */ - def litAggr[A: TypedEncoder, T](value: A): TypedAggregate[T, A] = - new TypedAggregate[T,A](lit(value).expr) - - - /** Creates a [[frameless.TypedColumn]] of literal value. If A is to be encoded using an Injection make - * sure the injection instance is in scope. - * - * apache/spark - */ - def lit[A: TypedEncoder, T](value: A): TypedColumn[T, A] = { - val encoder = TypedEncoder[A] - - if (ScalaReflection.isNativeType(encoder.jvmRepr) && encoder.catalystRepr == encoder.jvmRepr) { - val expr = Literal(value, encoder.catalystRepr) - new TypedColumn(expr) - } else { - val expr = FramelessLit(value, encoder) - new TypedColumn(expr) - } - } -} diff --git a/dataset/src/main/scala/frameless/ops/AggregateTypes.scala b/dataset/src/main/scala/frameless/ops/AggregateTypes.scala deleted file mode 100644 index 403c25301..000000000 --- a/dataset/src/main/scala/frameless/ops/AggregateTypes.scala +++ /dev/null @@ -1,28 +0,0 @@ -package frameless -package ops - -import shapeless._ - -/** A type class to extract the column types out of an HList of [[frameless.TypedAggregate]]. - * - * @note This type class is mostly a workaround to issue with slow implicit derivation for Comapped. - * @example - * {{{ - * type U = TypedAggregate[T,A] :: TypedAggregate[T,B] :: TypedAggregate[T,C] :: HNil - * type Out = A :: B :: C :: HNil - * }}} - */ -trait AggregateTypes[V, U <: HList] { - type Out <: HList -} - -object AggregateTypes { - type Aux[V, U <: HList, Out0 <: HList] = AggregateTypes[V, U] {type Out = Out0} - - implicit def deriveHNil[T]: AggregateTypes.Aux[T, HNil, HNil] = new AggregateTypes[T, HNil] { type Out = HNil } - - implicit def deriveCons1[T, H, TT <: HList, V <: HList]( - implicit tail: AggregateTypes.Aux[T, TT, V] - ): AggregateTypes.Aux[T, TypedAggregate[T, H] :: TT, H :: V] = - new AggregateTypes[T, TypedAggregate[T, H] :: TT] {type Out = H :: V} -} diff --git a/dataset/src/main/scala/frameless/ops/As.scala b/dataset/src/main/scala/frameless/ops/As.scala deleted file mode 100644 index 06b691028..000000000 --- a/dataset/src/main/scala/frameless/ops/As.scala +++ /dev/null @@ -1,40 +0,0 @@ -package frameless -package ops - -import shapeless.{::, Generic, HList, Lazy} - -/** Evidence for correctness of `TypedDataset[T].as[U]` */ -class As[T, U] private (implicit val encoder: TypedEncoder[U]) - -object As extends LowPriorityAs { - - final class Equiv[A, B] private[ops] () - - implicit def equivIdentity[A] = new Equiv[A, A] - - implicit def deriveAs[A, B] - (implicit - i0: TypedEncoder[B], - i1: Equiv[A, B] - ): As[A, B] = new As[A, B] - -} - -trait LowPriorityAs { - - import As.Equiv - - implicit def equivHList[AH, AT <: HList, BH, BT <: HList] - (implicit - i0: Lazy[Equiv[AH, BH]], - i1: Equiv[AT, BT] - ): Equiv[AH :: AT, BH :: BT] = new Equiv[AH :: AT, BH :: BT] - - implicit def equivGeneric[A, B, R, S] - (implicit - i0: Generic.Aux[A, R], - i1: Generic.Aux[B, S], - i2: Lazy[Equiv[R, S]] - ): Equiv[A, B] = new Equiv[A, B] - -} diff --git a/dataset/src/main/scala/frameless/ops/ColumnTypes.scala b/dataset/src/main/scala/frameless/ops/ColumnTypes.scala deleted file mode 100644 index e5ae6aea2..000000000 --- a/dataset/src/main/scala/frameless/ops/ColumnTypes.scala +++ /dev/null @@ -1,28 +0,0 @@ -package frameless -package ops - -import shapeless._ - -/** A type class to extract the column types out of an HList of [[frameless.TypedColumn]]. - * - * @note This type class is mostly a workaround to issue with slow implicit derivation for Comapped. - * @example - * {{{ - * type U = TypedColumn[T,A] :: TypedColumn[T,B] :: TypedColumn[T,C] :: HNil - * type Out = A :: B :: C :: HNil - * }}} - */ -trait ColumnTypes[T, U <: HList] { - type Out <: HList -} - -object ColumnTypes { - type Aux[T, U <: HList, Out0 <: HList] = ColumnTypes[T, U] {type Out = Out0} - - implicit def deriveHNil[T]: ColumnTypes.Aux[T, HNil, HNil] = new ColumnTypes[T, HNil] { type Out = HNil } - - implicit def deriveCons[T, H, TT <: HList, V <: HList]( - implicit tail: ColumnTypes.Aux[T, TT, V] - ): ColumnTypes.Aux[T, TypedColumn[T, H] :: TT, H :: V] = - new ColumnTypes[T, TypedColumn[T, H] :: TT] {type Out = H :: V} -} diff --git a/dataset/src/main/scala/frameless/ops/GroupByOps.scala b/dataset/src/main/scala/frameless/ops/GroupByOps.scala deleted file mode 100644 index 0891c43a6..000000000 --- a/dataset/src/main/scala/frameless/ops/GroupByOps.scala +++ /dev/null @@ -1,266 +0,0 @@ -package frameless -package ops - -import org.apache.spark.sql.catalyst.analysis.UnresolvedAlias -import org.apache.spark.sql.catalyst.plans.logical.{MapGroups, Project} -import org.apache.spark.sql.{Column, Dataset, FramelessInternals, RelationalGroupedDataset} -import shapeless._ -import shapeless.ops.hlist.{Length, Mapped, Prepend, ToList, ToTraversable, Tupler} - -class GroupedByManyOps[T, TK <: HList, K <: HList, KT] - (self: TypedDataset[T], groupedBy: TK) - (implicit - i0: ColumnTypes.Aux[T, TK, K], - i1: ToTraversable.Aux[TK, List, UntypedExpression[T]], - i3: Tupler.Aux[K, KT] - ) extends AggregatingOps[T, TK, K, KT](self, groupedBy, (dataset, cols) => dataset.groupBy(cols: _*)) { - object agg extends ProductArgs { - def applyProduct[TC <: HList, C <: HList, Out0 <: HList, Out1] - (columns: TC) - (implicit - i3: AggregateTypes.Aux[T, TC, C], - i4: Prepend.Aux[K, C, Out0], - i5: Tupler.Aux[Out0, Out1], - i6: TypedEncoder[Out1], - i7: ToTraversable.Aux[TC, List, UntypedExpression[T]] - ): TypedDataset[Out1] = { - aggregate[TC, Out1](columns) - } - } -} - -class GroupedBy1Ops[K1, V]( - self: TypedDataset[V], - g1: TypedColumn[V, K1] -) { - private def underlying = new GroupedByManyOps(self, g1 :: HNil) - private implicit def eg1 = g1.uencoder - - def agg[U1](c1: TypedAggregate[V, U1]): TypedDataset[(K1, U1)] = { - implicit val e1 = c1.uencoder - underlying.agg(c1) - } - - def agg[U1, U2](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2]): TypedDataset[(K1, U1, U2)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder - underlying.agg(c1, c2) - } - - def agg[U1, U2, U3](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2], c3: TypedAggregate[V, U3]): TypedDataset[(K1, U1, U2, U3)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder; implicit val e3 = c3.uencoder - underlying.agg(c1, c2, c3) - } - - def agg[U1, U2, U3, U4](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2], c3: TypedAggregate[V, U3], c4: TypedAggregate[V, U4]): TypedDataset[(K1, U1, U2, U3, U4)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder; implicit val e3 = c3.uencoder; implicit val e4 = c4.uencoder - underlying.agg(c1, c2, c3, c4) - } - - def agg[U1, U2, U3, U4, U5](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2], c3: TypedAggregate[V, U3], c4: TypedAggregate[V, U4], c5: TypedAggregate[V, U5]): TypedDataset[(K1, U1, U2, U3, U4, U5)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder; implicit val e3 = c3.uencoder; implicit val e4 = c4.uencoder; implicit val e5 = c5.uencoder - underlying.agg(c1, c2, c3, c4, c5) - } - - /** Methods on `TypedDataset[T]` that go through a full serialization and - * deserialization of `T`, and execute outside of the Catalyst runtime. - */ - object deserialized { - def mapGroups[U: TypedEncoder](f: (K1, Iterator[V]) => U): TypedDataset[U] = { - underlying.deserialized.mapGroups(AggregatingOps.tuple1(f)) - } - - def flatMapGroups[U: TypedEncoder](f: (K1, Iterator[V]) => TraversableOnce[U]): TypedDataset[U] = { - underlying.deserialized.flatMapGroups(AggregatingOps.tuple1(f)) - } - } - - def pivot[P: CatalystPivotable](pivotColumn: TypedColumn[V, P]): PivotNotValues[V, TypedColumn[V,K1] :: HNil, P] = - PivotNotValues(self, g1 :: HNil, pivotColumn) -} - - -class GroupedBy2Ops[K1, K2, V]( - self: TypedDataset[V], - g1: TypedColumn[V, K1], - g2: TypedColumn[V, K2] -) { - private def underlying = new GroupedByManyOps(self, g1 :: g2 :: HNil) - private implicit def eg1 = g1.uencoder - private implicit def eg2 = g2.uencoder - - def agg[U1](c1: TypedAggregate[V, U1]): TypedDataset[(K1, K2, U1)] = { - implicit val e1 = c1.uencoder - underlying.agg(c1) - } - - def agg[U1, U2](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2]): TypedDataset[(K1, K2, U1, U2)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder - underlying.agg(c1, c2) - } - - def agg[U1, U2, U3](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2], c3: TypedAggregate[V, U3]): TypedDataset[(K1, K2, U1, U2, U3)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder; implicit val e3 = c3.uencoder - underlying.agg(c1, c2, c3) - } - - def agg[U1, U2, U3, U4](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2], c3: TypedAggregate[V, U3], c4: TypedAggregate[V, U4]): TypedDataset[(K1, K2, U1, U2, U3, U4)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder; implicit val e3 = c3.uencoder; implicit val e4 = c4.uencoder - underlying.agg(c1 , c2 , c3 , c4) - } - - def agg[U1, U2, U3, U4, U5](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2], c3: TypedAggregate[V, U3], c4: TypedAggregate[V, U4], c5: TypedAggregate[V, U5]): TypedDataset[(K1, K2, U1, U2, U3, U4, U5)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder; implicit val e3 = c3.uencoder; implicit val e4 = c4.uencoder; implicit val e5 = c5.uencoder - underlying.agg(c1, c2, c3, c4, c5) - } - - - /** Methods on `TypedDataset[T]` that go through a full serialization and - * deserialization of `T`, and execute outside of the Catalyst runtime. - */ - object deserialized { - def mapGroups[U: TypedEncoder](f: ((K1, K2), Iterator[V]) => U): TypedDataset[U] = { - underlying.deserialized.mapGroups(f) - } - - def flatMapGroups[U: TypedEncoder](f: ((K1, K2), Iterator[V]) => TraversableOnce[U]): TypedDataset[U] = { - underlying.deserialized.flatMapGroups(f) - } - } - - def pivot[P: CatalystPivotable](pivotColumn: TypedColumn[V, P]): - PivotNotValues[V, TypedColumn[V,K1] :: TypedColumn[V, K2] :: HNil, P] = - PivotNotValues(self, g1 :: g2 :: HNil, pivotColumn) -} - -private[ops] abstract class AggregatingOps[T, TK <: HList, K <: HList, KT] - (self: TypedDataset[T], groupedBy: TK, groupingFunc: (Dataset[T], Seq[Column]) => RelationalGroupedDataset) - (implicit - i0: ColumnTypes.Aux[T, TK, K], - i1: ToTraversable.Aux[TK, List, UntypedExpression[T]], - i2: Tupler.Aux[K, KT] - ) { - def aggregate[TC <: HList, Out1](columns: TC) - (implicit - i7: TypedEncoder[Out1], - i8: ToTraversable.Aux[TC, List, UntypedExpression[T]] - ): TypedDataset[Out1] = { - def expr(c: UntypedExpression[T]): Column = new Column(c.expr) - - val groupByExprs = groupedBy.toList[UntypedExpression[T]].map(expr) - val aggregates = - if (retainGroupColumns) columns.toList[UntypedExpression[T]].map(expr) - else groupByExprs ++ columns.toList[UntypedExpression[T]].map(expr) - - val aggregated = - groupingFunc(self.dataset, groupByExprs) - .agg(aggregates.head, aggregates.tail: _*) - .as[Out1](TypedExpressionEncoder[Out1]) - - TypedDataset.create[Out1](aggregated) - } - - /** Methods on `TypedDataset[T]` that go through a full serialization and - * deserialization of `T`, and execute outside of the Catalyst runtime. - */ - object deserialized { - def mapGroups[U: TypedEncoder]( - f: (KT, Iterator[T]) => U - )(implicit e: TypedEncoder[KT]): TypedDataset[U] = { - val func = (key: KT, it: Iterator[T]) => Iterator(f(key, it)) - flatMapGroups(func) - } - - def flatMapGroups[U: TypedEncoder]( - f: (KT, Iterator[T]) => TraversableOnce[U] - )(implicit e: TypedEncoder[KT]): TypedDataset[U] = { - implicit val tendcoder = self.encoder - - val cols = groupedBy.toList[UntypedExpression[T]] - val logicalPlan = FramelessInternals.logicalPlan(self.dataset) - val withKeyColumns = logicalPlan.output ++ cols.map(_.expr).map(UnresolvedAlias(_)) - val withKey = Project(withKeyColumns, logicalPlan) - val executed = FramelessInternals.executePlan(self.dataset, withKey) - val keyAttributes = executed.analyzed.output.takeRight(cols.size) - val dataAttributes = executed.analyzed.output.dropRight(cols.size) - - val mapGroups = MapGroups( - f, - keyAttributes, - dataAttributes, - executed.analyzed - )(TypedExpressionEncoder[KT], TypedExpressionEncoder[T], TypedExpressionEncoder[U]) - - val groupedAndFlatMapped = FramelessInternals.mkDataset( - self.dataset.sqlContext, - mapGroups, - TypedExpressionEncoder[U] - ) - - TypedDataset.create(groupedAndFlatMapped) - } - } - - private def retainGroupColumns: Boolean = { - self.dataset.sqlContext.getConf("spark.sql.retainGroupColumns", "true").toBoolean - } - - def pivot[P: CatalystPivotable](pivotColumn: TypedColumn[T, P]): PivotNotValues[T, TK, P] = - PivotNotValues(self, groupedBy, pivotColumn) -} - -private[ops] object AggregatingOps { - /** Utility function to help Spark with serialization of closures */ - def tuple1[K1, V, U](f: (K1, Iterator[V]) => U): (Tuple1[K1], Iterator[V]) => U = { - (x: Tuple1[K1], it: Iterator[V]) => f(x._1, it) - } -} - -/** Represents a typed Pivot operation. - */ -final case class Pivot[T, GroupedColumns <: HList, PivotType, Values <: HList]( - ds: TypedDataset[T], - groupedBy: GroupedColumns, - pivotedBy: TypedColumn[T, PivotType], - values: Values -) { - - object agg extends ProductArgs { - def applyProduct[AggrColumns <: HList, AggrColumnTypes <: HList, GroupedColumnTypes <: HList, NumValues <: Nat, TypesForPivotedValues <: HList, TypesForPivotedValuesOpt <: HList, OutAsHList <: HList, Out] - (aggrColumns: AggrColumns) - (implicit - i0: AggregateTypes.Aux[T, AggrColumns, AggrColumnTypes], - i1: ColumnTypes.Aux[T, GroupedColumns, GroupedColumnTypes], - i2: Length.Aux[Values, NumValues], - i3: Repeat.Aux[AggrColumnTypes, NumValues, TypesForPivotedValues], - i4: Mapped.Aux[TypesForPivotedValues, Option, TypesForPivotedValuesOpt], - i5: Prepend.Aux[GroupedColumnTypes, TypesForPivotedValuesOpt, OutAsHList], - i6: Tupler.Aux[OutAsHList, Out], - i7: TypedEncoder[Out] - ): TypedDataset[Out] = { - def mapAny[X](h: HList)(f: Any => X): List[X] = - h match { - case HNil => Nil - case x :: xs => f(x) :: mapAny(xs)(f) - } - - val aggCols: Seq[Column] = mapAny(aggrColumns)(x => new Column(x.asInstanceOf[TypedAggregate[_,_]].expr)) - val tmp = ds.dataset.toDF() - .groupBy(mapAny(groupedBy)(_.asInstanceOf[TypedColumn[_, _]].untyped): _*) - .pivot(pivotedBy.untyped.toString, mapAny(values)(identity)) - .agg(aggCols.head, aggCols.tail:_*) - .as[Out](TypedExpressionEncoder[Out]) - TypedDataset.create(tmp) - } - } -} - -final case class PivotNotValues[T, GroupedColumns <: HList, PivotType]( - ds: TypedDataset[T], - groupedBy: GroupedColumns, - pivotedBy: TypedColumn[T, PivotType] -) extends ProductArgs { - - def onProduct[Values <: HList](values: Values)( - implicit validValues: ToList[Values, PivotType] // validValues: FilterNot.Aux[Values, PivotType, HNil] // did not work - ): Pivot[T, GroupedColumns, PivotType, Values] = Pivot(ds, groupedBy, pivotedBy, values) -} diff --git a/dataset/src/main/scala/frameless/ops/RelationalGroupsOps.scala b/dataset/src/main/scala/frameless/ops/RelationalGroupsOps.scala deleted file mode 100644 index 569407762..000000000 --- a/dataset/src/main/scala/frameless/ops/RelationalGroupsOps.scala +++ /dev/null @@ -1,168 +0,0 @@ -package frameless -package ops - -import org.apache.spark.sql.{Column, Dataset, RelationalGroupedDataset} -import shapeless.ops.hlist.{Mapped, Prepend, ToTraversable, Tupler} -import shapeless.{::, HList, HNil, ProductArgs} - -/** - * @param groupingFunc functions used to group elements, can be cube or rollup - * @tparam T the original `TypedDataset's` type T - * @tparam TK all columns chosen for aggregation - * @tparam K individual columns' types as HList - * @tparam KT individual columns' types as Tuple - */ -private[ops] abstract class RelationalGroupsOps[T, TK <: HList, K <: HList, KT] - (self: TypedDataset[T], groupedBy: TK, groupingFunc: (Dataset[T], Seq[Column]) => RelationalGroupedDataset) - (implicit - i0: ColumnTypes.Aux[T, TK, K], - i1: ToTraversable.Aux[TK, List, UntypedExpression[T]], - i2: Tupler.Aux[K, KT] - ) extends AggregatingOps(self, groupedBy, groupingFunc){ - - object agg extends ProductArgs { - /** - * @tparam TC resulting columns after aggregation function - * @tparam C individual columns' types as HList - * @tparam OptK columns' types mapped to Option - * @tparam Out0 OptK columns appended to C - * @tparam Out1 output type - */ - def applyProduct[TC <: HList, C <: HList, OptK <: HList, Out0 <: HList, Out1] - (columns: TC) - (implicit - i3: AggregateTypes.Aux[T, TC, C], // shares individual columns' types after agg function as HList - i4: Mapped.Aux[K, Option, OptK], // maps all original columns' types to Option - i5: Prepend.Aux[OptK, C, Out0], // concatenates Option columns with those resulting from applying agg function - i6: Tupler.Aux[Out0, Out1], // converts resulting HList into Tuple for output type - i7: TypedEncoder[Out1], // proof that there is `TypedEncoder` for the output type - i8: ToTraversable.Aux[TC, List, UntypedExpression[T]] // allows converting this HList to ordinary List - ): TypedDataset[Out1] = { - aggregate[TC, Out1](columns) - } - } -} - -private[ops] abstract class RelationalGroups1Ops[K1, V](self: TypedDataset[V], g1: TypedColumn[V, K1]) { - protected def underlying: RelationalGroupsOps[V, ::[TypedColumn[V, K1], HNil], ::[K1, HNil], Tuple1[K1]] - private implicit def eg1 = g1.uencoder - - def agg[U1](c1: TypedAggregate[V, U1]): TypedDataset[(Option[K1], U1)] = { - implicit val e1 = c1.uencoder - underlying.agg(c1) - } - - def agg[U1, U2](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2]): TypedDataset[(Option[K1], U1, U2)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder - underlying.agg(c1, c2) - } - - def agg[U1, U2, U3](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2], c3: TypedAggregate[V, U3]): TypedDataset[(Option[K1], U1, U2, U3)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder; implicit val e3 = c3.uencoder - underlying.agg(c1, c2, c3) - } - - def agg[U1, U2, U3, U4](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2], c3: TypedAggregate[V, U3], c4: TypedAggregate[V, U4]): TypedDataset[(Option[K1], U1, U2, U3, U4)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder; implicit val e3 = c3.uencoder; implicit val e4 = c4.uencoder - underlying.agg(c1, c2, c3, c4) - } - - def agg[U1, U2, U3, U4, U5](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2], c3: TypedAggregate[V, U3], c4: TypedAggregate[V, U4], c5: TypedAggregate[V, U5]): TypedDataset[(Option[K1], U1, U2, U3, U4, U5)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder; implicit val e3 = c3.uencoder; implicit val e4 = c4.uencoder; implicit val e5 = c5.uencoder - underlying.agg(c1, c2, c3, c4, c5) - } - - /** Methods on `TypedDataset[T]` that go through a full serialization and - * deserialization of `T`, and execute outside of the Catalyst runtime. - */ - object deserialized { - def mapGroups[U: TypedEncoder](f: (K1, Iterator[V]) => U): TypedDataset[U] = { - underlying.deserialized.mapGroups(AggregatingOps.tuple1(f)) - } - - def flatMapGroups[U: TypedEncoder](f: (K1, Iterator[V]) => TraversableOnce[U]): TypedDataset[U] = { - underlying.deserialized.flatMapGroups(AggregatingOps.tuple1(f)) - } - } - - def pivot[P: CatalystPivotable](pivotColumn: TypedColumn[V, P]): PivotNotValues[V, TypedColumn[V,K1] :: HNil, P] = - PivotNotValues(self, g1 :: HNil, pivotColumn) -} - -private[ops] abstract class RelationalGroups2Ops[K1, K2, V](self: TypedDataset[V], g1: TypedColumn[V, K1], g2: TypedColumn[V, K2]) { - protected def underlying: RelationalGroupsOps[V, ::[TypedColumn[V, K1], ::[TypedColumn[V, K2], HNil]], ::[K1, ::[K2, HNil]], (K1, K2)] - private implicit def eg1 = g1.uencoder - private implicit def eg2 = g2.uencoder - - def agg[U1](c1: TypedAggregate[V, U1]): TypedDataset[(Option[K1], Option[K2], U1)] = { - implicit val e1 = c1.uencoder - underlying.agg(c1) - } - - def agg[U1, U2](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2]): TypedDataset[(Option[K1], Option[K2], U1, U2)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder - underlying.agg(c1, c2) - } - - def agg[U1, U2, U3](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2], c3: TypedAggregate[V, U3]): TypedDataset[(Option[K1], Option[K2], U1, U2, U3)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder; implicit val e3 = c3.uencoder - underlying.agg(c1, c2, c3) - } - - def agg[U1, U2, U3, U4](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2], c3: TypedAggregate[V, U3], c4: TypedAggregate[V, U4]): TypedDataset[(Option[K1], Option[K2], U1, U2, U3, U4)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder; implicit val e3 = c3.uencoder; implicit val e4 = c4.uencoder - underlying.agg(c1 , c2 , c3 , c4) - } - - def agg[U1, U2, U3, U4, U5](c1: TypedAggregate[V, U1], c2: TypedAggregate[V, U2], c3: TypedAggregate[V, U3], c4: TypedAggregate[V, U4], c5: TypedAggregate[V, U5]): TypedDataset[(Option[K1], Option[K2], U1, U2, U3, U4, U5)] = { - implicit val e1 = c1.uencoder; implicit val e2 = c2.uencoder; implicit val e3 = c3.uencoder; implicit val e4 = c4.uencoder; implicit val e5 = c5.uencoder - underlying.agg(c1, c2, c3, c4, c5) - } - - /** Methods on `TypedDataset[T]` that go through a full serialization and - * deserialization of `T`, and execute outside of the Catalyst runtime. - */ - object deserialized { - def mapGroups[U: TypedEncoder](f: ((K1, K2), Iterator[V]) => U): TypedDataset[U] = { - underlying.deserialized.mapGroups(f) - } - - def flatMapGroups[U: TypedEncoder](f: ((K1, K2), Iterator[V]) => TraversableOnce[U]): TypedDataset[U] = { - underlying.deserialized.flatMapGroups(f) - } - } - - def pivot[P: CatalystPivotable](pivotColumn: TypedColumn[V, P]): - PivotNotValues[V, TypedColumn[V,K1] :: TypedColumn[V, K2] :: HNil, P] = - PivotNotValues(self, g1 :: g2 :: HNil, pivotColumn) -} - -class RollupManyOps[T, TK <: HList, K <: HList, KT](self: TypedDataset[T], groupedBy: TK) - (implicit - i0: ColumnTypes.Aux[T, TK, K], - i1: ToTraversable.Aux[TK, List, UntypedExpression[T]], - i2: Tupler.Aux[K, KT] - ) extends RelationalGroupsOps[T, TK, K, KT](self, groupedBy, (dataset, cols) => dataset.rollup(cols: _*)) - -class Rollup1Ops[K1, V](self: TypedDataset[V], g1: TypedColumn[V, K1]) extends RelationalGroups1Ops(self, g1) { - override protected def underlying = new RollupManyOps(self, g1 :: HNil) -} - -class Rollup2Ops[K1, K2, V](self: TypedDataset[V], g1: TypedColumn[V, K1], g2: TypedColumn[V, K2]) extends RelationalGroups2Ops(self, g1, g2) { - override protected def underlying = new RollupManyOps(self, g1 :: g2 :: HNil) -} - -class CubeManyOps[T, TK <: HList, K <: HList, KT](self: TypedDataset[T], groupedBy: TK) - (implicit - i0: ColumnTypes.Aux[T, TK, K], - i1: ToTraversable.Aux[TK, List, UntypedExpression[T]], - i2: Tupler.Aux[K, KT] - ) extends RelationalGroupsOps[T, TK, K, KT](self, groupedBy, (dataset, cols) => dataset.cube(cols: _*)) - -class Cube1Ops[K1, V](self: TypedDataset[V], g1: TypedColumn[V, K1]) extends RelationalGroups1Ops(self, g1) { - override protected def underlying = new CubeManyOps(self, g1 :: HNil) -} - -class Cube2Ops[K1, K2, V](self: TypedDataset[V], g1: TypedColumn[V, K1], g2: TypedColumn[V, K2]) extends RelationalGroups2Ops(self, g1, g2) { - override protected def underlying = new CubeManyOps(self, g1 :: g2 :: HNil) -} diff --git a/dataset/src/main/scala/frameless/ops/Repeat.scala b/dataset/src/main/scala/frameless/ops/Repeat.scala deleted file mode 100644 index bde855500..000000000 --- a/dataset/src/main/scala/frameless/ops/Repeat.scala +++ /dev/null @@ -1,33 +0,0 @@ -package frameless -package ops - -import shapeless.{HList, Nat, Succ} -import shapeless.ops.hlist.Prepend - -/** Typeclass supporting repeating L-typed HLists N times. - * - * Repeat[Int :: String :: HNil, Nat._2].Out =:= - * Int :: String :: Int :: String :: HNil - * - * By Jeremy Smith. To be replaced by `shapeless.ops.hlists.Repeat` - * once (https://github.com/milessabin/shapeless/pull/730 is published. - */ -trait Repeat[L <: HList, N <: Nat] { - type Out <: HList -} - -object Repeat { - type Aux[L <: HList, N <: Nat, Out0 <: HList] = Repeat[L, N] { type Out = Out0 } - - implicit def base[L <: HList]: Aux[L, Nat._1, L] = new Repeat[L, Nat._1] { - type Out = L - } - - implicit def succ[L <: HList, Prev <: Nat, PrevOut <: HList, P <: HList] - (implicit - i0: Aux[L, Prev, PrevOut], - i1: Prepend.Aux[L, PrevOut, P] - ): Aux[L, Succ[Prev], P] = new Repeat[L, Succ[Prev]] { - type Out = P - } -} diff --git a/dataset/src/main/scala/frameless/ops/SmartProject.scala b/dataset/src/main/scala/frameless/ops/SmartProject.scala deleted file mode 100644 index 27e1f734e..000000000 --- a/dataset/src/main/scala/frameless/ops/SmartProject.scala +++ /dev/null @@ -1,48 +0,0 @@ -package frameless -package ops - -import shapeless.ops.hlist.ToTraversable -import shapeless.ops.record.{Keys, SelectAll, Values} -import shapeless.{HList, LabelledGeneric} - -import scala.annotation.implicitNotFound - -@implicitNotFound(msg = "Cannot prove that ${T} can be projected to ${U}. Perhaps not all member names and types of ${U} are the same in ${T}?") -case class SmartProject[T: TypedEncoder, U: TypedEncoder](apply: TypedDataset[T] => TypedDataset[U]) - -object SmartProject { - /** - * Proofs that there is a type-safe projection from a type T to another type U. It requires that: - * (a) both T and U are Products for which a LabelledGeneric can be derived (e.g., case classes), - * (b) all members of U have a corresponding member in T that has both the same name and type. - * - * @param i0 the LabelledGeneric derived for T - * @param i1 the LabelledGeneric derived for U - * @param i2 the keys of U - * @param i3 selects all the values from T using the keys of U - * @param i4 selects all the values of LabeledGeneric[U] - * @param i5 proof that U and the projection of T have the same type - * @param i6 allows for traversing the keys of U - * @tparam T the original type T - * @tparam U the projected type U - * @tparam TRec shapeless' Record representation of T - * @tparam TProj the projection of T using the keys of U - * @tparam URec shapeless' Record representation of U - * @tparam UVals the values of U as an HList - * @tparam UKeys the keys of U as an HList - * @return a projection if it exists - */ - implicit def deriveProduct[T: TypedEncoder, U: TypedEncoder, TRec <: HList, TProj <: HList, URec <: HList, UVals <: HList, UKeys <: HList] - (implicit - i0: LabelledGeneric.Aux[T, TRec], - i1: LabelledGeneric.Aux[U, URec], - i2: Keys.Aux[URec, UKeys], - i3: SelectAll.Aux[TRec, UKeys, TProj], - i4: Values.Aux[URec, UVals], - i5: UVals =:= TProj, - i6: ToTraversable.Aux[UKeys, Seq, Symbol] - ): SmartProject[T,U] = SmartProject[T, U]({ from => - val names = implicitly[Keys.Aux[URec, UKeys]].apply.to[Seq].map(_.name).map(from.dataset.col) - TypedDataset.create(from.dataset.toDF().select(names: _*).as[U](TypedExpressionEncoder[U])) - }) -} diff --git a/dataset/src/main/scala/frameless/syntax/package.scala b/dataset/src/main/scala/frameless/syntax/package.scala deleted file mode 100644 index c6045981f..000000000 --- a/dataset/src/main/scala/frameless/syntax/package.scala +++ /dev/null @@ -1,5 +0,0 @@ -package frameless - -package object syntax extends FramelessSyntax { - implicit val DefaultSparkDelay: SparkDelay[Job] = Job.framelessSparkDelayForJob -} diff --git a/dataset/src/main/scala/org/apache/spark/sql/FramelessInternals.scala b/dataset/src/main/scala/org/apache/spark/sql/FramelessInternals.scala deleted file mode 100644 index 842e04cfc..000000000 --- a/dataset/src/main/scala/org/apache/spark/sql/FramelessInternals.scala +++ /dev/null @@ -1,73 +0,0 @@ -package org.apache.spark.sql - -import org.apache.spark.sql.catalyst.expressions._ -import org.apache.spark.sql.catalyst.expressions.codegen._ -import org.apache.spark.sql.catalyst.expressions.{Alias, CreateStruct} -import org.apache.spark.sql.catalyst.expressions.{Expression, NamedExpression} -import org.apache.spark.sql.catalyst.InternalRow -import org.apache.spark.sql.catalyst.plans.logical.LogicalPlan -import org.apache.spark.sql.catalyst.plans.logical.{LogicalPlan, Project} -import org.apache.spark.sql.execution.QueryExecution -import org.apache.spark.sql.types._ -import org.apache.spark.sql.types.ObjectType -import scala.reflect.ClassTag - -object FramelessInternals { - def objectTypeFor[A](implicit classTag: ClassTag[A]): ObjectType = ObjectType(classTag.runtimeClass) - - def resolveExpr(ds: Dataset[_], colNames: Seq[String]): NamedExpression = { - ds.toDF.queryExecution.analyzed.resolve(colNames, ds.sparkSession.sessionState.analyzer.resolver).getOrElse { - throw new AnalysisException( - s"""Cannot resolve column name "$colNames" among (${ds.schema.fieldNames.mkString(", ")})""") - } - } - - def expr(column: Column): Expression = column.expr - - def column(column: Column): Expression = column.expr - - def logicalPlan(ds: Dataset[_]): LogicalPlan = ds.logicalPlan - - def executePlan(ds: Dataset[_], plan: LogicalPlan): QueryExecution = - ds.sparkSession.sessionState.executePlan(plan) - - def joinPlan(ds: Dataset[_], plan: LogicalPlan, leftPlan: LogicalPlan, rightPlan: LogicalPlan): LogicalPlan = { - val joined = executePlan(ds, plan) - val leftOutput = joined.analyzed.output.take(leftPlan.output.length) - val rightOutput = joined.analyzed.output.takeRight(rightPlan.output.length) - - Project(List( - Alias(CreateStruct(leftOutput), "_1")(), - Alias(CreateStruct(rightOutput), "_2")() - ), joined.analyzed) - } - - def mkDataset[T](sqlContext: SQLContext, plan: LogicalPlan, encoder: Encoder[T]): Dataset[T] = - new Dataset(sqlContext, plan, encoder) - - def ofRows(sparkSession: SparkSession, logicalPlan: LogicalPlan): DataFrame = - Dataset.ofRows(sparkSession, logicalPlan) - - // because org.apache.spark.sql.types.UserDefinedType is private[spark] - type UserDefinedType[A >: Null] = org.apache.spark.sql.types.UserDefinedType[A] - - /** Expression to tag columns from the left hand side of join expression. */ - case class DisambiguateLeft[T](tagged: Expression) extends Expression with NonSQLExpression { - def eval(input: InternalRow): Any = tagged.eval(input) - def nullable: Boolean = false - def children: Seq[Expression] = tagged :: Nil - def dataType: DataType = tagged.dataType - protected def doGenCode(ctx: CodegenContext, ev: ExprCode): ExprCode = ??? - override def genCode(ctx: CodegenContext): ExprCode = tagged.genCode(ctx) - } - - /** Expression to tag columns from the right hand side of join expression. */ - case class DisambiguateRight[T](tagged: Expression) extends Expression with NonSQLExpression { - def eval(input: InternalRow): Any = tagged.eval(input) - def nullable: Boolean = false - def children: Seq[Expression] = tagged :: Nil - def dataType: DataType = tagged.dataType - protected def doGenCode(ctx: CodegenContext, ev: ExprCode): ExprCode = ??? - override def genCode(ctx: CodegenContext): ExprCode = tagged.genCode(ctx) - } -} diff --git a/dataset/src/test/resources/log4j.properties b/dataset/src/test/resources/log4j.properties deleted file mode 100644 index 044f9440b..000000000 --- a/dataset/src/test/resources/log4j.properties +++ /dev/null @@ -1,146 +0,0 @@ -log4j.logger.akka.event.slf4j.Slf4jLogger=ERROR -log4j.logger.akka.event.slf4j=ERROR -log4j.logger.akka.remote.EndpointWriter=ERROR -log4j.logger.akka.remote.RemoteActorRefProvider$RemotingTerminator=ERROR -log4j.logger.com.anjuke.dm=ERROR -log4j.logger.io.netty.bootstrap.ServerBootstrap=ERROR -log4j.logger.io.netty.buffer.ByteBufUtil=ERROR -log4j.logger.io.netty.buffer.PooledByteBufAllocator=ERROR -log4j.logger.io.netty.channel.AbstractChannel=ERROR -log4j.logger.io.netty.channel.ChannelInitializer=ERROR -log4j.logger.io.netty.channel.ChannelOutboundBuffer=ERROR -log4j.logger.io.netty.channel.DefaultChannelPipeline=ERROR -log4j.logger.io.netty.channel.MultithreadEventLoopGroup=ERROR -log4j.logger.io.netty.channel.nio.AbstractNioChannel=ERROR -log4j.logger.io.netty.channel.nio.NioEventLoop=ERROR -log4j.logger.io.netty.channel.socket.nio.NioServerSocketChannel=ERROR -log4j.logger.io.netty.util.concurrent.DefaultPromise.rejectedExecution=ERROR -log4j.logger.io.netty.util.concurrent.DefaultPromise=ERROR -log4j.logger.io.netty.util.concurrent.GlobalEventExecutor=ERROR -log4j.logger.io.netty.util.concurrent.SingleThreadEventExecutor=ERROR -log4j.logger.io.netty.util.internal.logging.InternalLoggerFactory=ERROR -log4j.logger.io.netty.util.internal.PlatformDependent0=ERROR -log4j.logger.io.netty.util.internal.PlatformDependent=ERROR -log4j.logger.io.netty.util.internal.SystemPropertyUtil=ERROR -log4j.logger.io.netty.util.internal.ThreadLocalRandom=ERROR -log4j.logger.io.netty.util.NetUtil=ERROR -log4j.logger.org.apache.hadoop.conf.Configuration.deprecation=ERROR -log4j.logger.org.apache.hadoop.conf.Configuration=ERROR -log4j.logger.org.apache.hadoop.fs.FileSystem=ERROR -log4j.logger.org.apache.hadoop.hive.metastore.RetryingHMSHandler=ERROR -log4j.logger.org.apache.hadoop.hive.ql.exec.FunctionRegistry=ERROR -log4j.logger.org.apache.hadoop.mapred.JobConf=ERROR -log4j.logger.org.apache.hadoop.mapreduce.lib.partition.KeyFieldBasedPartitioner=ERROR -log4j.logger.org.apache.hadoop.metrics2.impl.MetricsSystemImpl=ERROR -log4j.logger.org.apache.hadoop.metrics2.lib.Interns=ERROR -log4j.logger.org.apache.hadoop.metrics2.lib.MetricsSourceBuilder=ERROR -log4j.logger.org.apache.hadoop.metrics2.lib.MutableMetricsFactory=ERROR -log4j.logger.org.apache.hadoop.security.authentication.util.KerberosName=ERROR -log4j.logger.org.apache.hadoop.security.Groups=ERROR -log4j.logger.org.apache.hadoop.security.JniBasedUnixGroupsMappingWithFallback=ERROR -log4j.logger.org.apache.hadoop.security.SecurityUtil=ERROR -log4j.logger.org.apache.hadoop.security.ShellBasedUnixGroupsMapping=ERROR -log4j.logger.org.apache.hadoop.security.UserGroupInformation=ERROR -log4j.logger.org.apache.hadoop.util.NativeCodeLoader=ERROR -log4j.logger.org.apache.hadoop.util.ShutdownHookManager=ERROR -log4j.logger.org.apache.spark.broadcast.TorrentBroadcast=ERROR -log4j.logger.org.apache.spark.ContextCleaner=ERROR -log4j.logger.org.apache.spark.executor.Executor=ERROR -log4j.logger.org.apache.spark.HeartbeatReceiver=ERROR -log4j.logger.org.apache.spark.HttpFileServer=ERROR -log4j.logger.org.apache.spark.HttpServer=ERROR -log4j.logger.org.apache.spark.MapOutputTrackerMaster=ERROR -log4j.logger.org.apache.spark.MapOutputTrackerMasterEndpoint=ERROR -log4j.logger.org.apache.spark.metrics.MetricsSystem=ERROR -log4j.logger.org.apache.spark.network.client.TransportClientFactory=ERROR -log4j.logger.org.apache.spark.network.netty.NettyBlockTransferService=ERROR -log4j.logger.org.apache.spark.network.protocol.MessageDecoder=ERROR -log4j.logger.org.apache.spark.network.protocol.MessageEncoder=ERROR -log4j.logger.org.apache.spark.network.server.OneForOneStreamManager=ERROR -log4j.logger.org.apache.spark.network.server.TransportServer=ERROR -log4j.logger.org.apache.spark.network.TransportContext=ERROR -log4j.logger.org.apache.spark.network.util.JavaUtils=ERROR -log4j.logger.org.apache.spark.rdd.CoGroupedRDD=ERROR -log4j.logger.org.apache.spark.rdd.SubtractedRDD=ERROR -log4j.logger.org.apache.spark.repl.SparkILoop$SparkILoopInterpreter=ERROR -log4j.logger.org.apache.spark.repl.SparkIMain$exprTyper=ERROR -log4j.logger.org.apache.spark.rpc.akka.AkkaRpcEnv$$anonfun$actorRef$lzycompute$1$1$$anon$1=ERROR -log4j.logger.org.apache.spark.scheduler.DAGScheduler=ERROR -log4j.logger.org.apache.spark.scheduler.OutputCommitCoordinator$OutputCommitCoordinatorEndpoint=ERROR -log4j.logger.org.apache.spark.scheduler.TaskSchedulerImpl=ERROR -log4j.logger.org.apache.spark.scheduler.TaskSetManager=ERROR -log4j.logger.org.apache.spark.SecurityManager=ERROR -log4j.logger.org.apache.spark.shuffle.sort.BypassMergeSortShuffleWriter=ERROR -log4j.logger.org.apache.spark.SparkContext=ERROR -log4j.logger.org.apache.spark.SparkEnv=ERROR -log4j.logger.org.apache.spark.sql.catalyst.analysis.Analyzer$ResolveReferences=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GenerateMutableProjection=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GenerateOrdering=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GeneratePredicate=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GenerateProjection=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GenerateSafeProjection=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GenerateUnsafeProjection=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.GenerateUnsafeRowJoiner=ERROR -log4j.logger.org.apache.spark.sql.catalyst.expressions.codegen.package$ExpressionCanonicalizer=ERROR -log4j.logger.org.apache.spark.sql.catalyst.optimizer.DefaultOptimizer=ERROR -log4j.logger.org.apache.spark.sql.catalyst.planning.ExtractEquiJoinKeys=ERROR -log4j.logger.org.apache.spark.sql.execution.aggregate.SortBasedAggregate=ERROR -log4j.logger.org.apache.spark.sql.execution.aggregate.TungstenAggregate=ERROR -log4j.logger.org.apache.spark.sql.execution.Exchange=ERROR -log4j.logger.org.apache.spark.sql.execution.joins.ShuffledHashOuterJoin=ERROR -log4j.logger.org.apache.spark.sql.SQLContext$$anon$1=ERROR -log4j.logger.org.apache.spark.sql.SQLContext$$anon$2=ERROR -log4j.logger.org.apache.spark.SSLOptions=ERROR -log4j.logger.org.apache.spark.storage.BlockManager=ERROR -log4j.logger.org.apache.spark.storage.BlockManagerInfo=ERROR -log4j.logger.org.apache.spark.storage.BlockManagerMaster=ERROR -log4j.logger.org.apache.spark.storage.BlockManagerMasterEndpoint=ERROR -log4j.logger.org.apache.spark.storage.BlockManagerSlaveEndpoint=ERROR -log4j.logger.org.apache.spark.storage.DiskBlockManager=ERROR -log4j.logger.org.apache.spark.storage.MemoryStore=ERROR -log4j.logger.org.apache.spark.storage.ShuffleBlockFetcherIterator=ERROR -log4j.logger.org.apache.spark.ui.SparkUI=ERROR -log4j.logger.org.apache.spark.unsafe.map.BytesToBytesMap=ERROR -log4j.logger.org.apache.spark.unsafe.memory.TaskMemoryManager=ERROR -log4j.logger.org.apache.spark.util.AkkaUtils=ERROR -log4j.logger.org.apache.spark.util.ClosureCleaner=ERROR -log4j.logger.org.apache.spark.util.collection.unsafe.sort.UnsafeExternalSorter=ERROR -log4j.logger.org.apache.spark.util.Utils=ERROR -log4j.logger.org.apache.spark=ERROR -log4j.logger.org.eclipse.jetty.util.component.AbstractLifeCycle=ERROR -log4j.logger.org.eclipse.jetty=ERROR -log4j.logger.org.spark-project.jetty.http.AbstractGenerator=ERROR -log4j.logger.org.spark-project.jetty.http.HttpGenerator=ERROR -log4j.logger.org.spark-project.jetty.http.MimeTypes=ERROR -log4j.logger.org.spark-project.jetty.io.AbstractBuffer=ERROR -log4j.logger.org.spark-project.jetty.io.nio=ERROR -log4j.logger.org.spark-project.jetty.server.AbstractConnector=ERROR -log4j.logger.org.spark-project.jetty.server.bio.SocketConnector=ERROR -log4j.logger.org.spark-project.jetty.server.handler.AbstractHandler=ERROR -log4j.logger.org.spark-project.jetty.server.handler.ContextHandler=ERROR -log4j.logger.org.spark-project.jetty.server.handler.ContextHandlerCollection=ERROR -log4j.logger.org.spark-project.jetty.server.handler.DefaultHandler=ERROR -log4j.logger.org.spark-project.jetty.server.handler.ErrorHandler=ERROR -log4j.logger.org.spark-project.jetty.server.handler.GzipHandler=ERROR -log4j.logger.org.spark-project.jetty.server.handler.ResourceHandler=ERROR -log4j.logger.org.spark-project.jetty.server.Server=ERROR -log4j.logger.org.spark-project.jetty.server=ERROR -log4j.logger.org.spark-project.jetty.servlet.DefaultServlet=ERROR -log4j.logger.org.spark-project.jetty.servlet.Holder=ERROR -log4j.logger.org.spark-project.jetty.servlet.ServletHandler=ERROR -log4j.logger.org.spark-project.jetty.servlet.ServletHolder=ERROR -log4j.logger.org.spark-project.jetty.util.component.AbstractLifeCycle=ERROR -log4j.logger.org.spark-project.jetty.util.component.AggregateLifeCycle=ERROR -log4j.logger.org.spark-project.jetty.util.component.Container=ERROR -log4j.logger.org.spark-project.jetty.util.IO=ERROR -log4j.logger.org.spark-project.jetty.util.log=ERROR -log4j.logger.org.spark-project.jetty.util.resource.FileResource=ERROR -log4j.logger.org.spark-project.jetty.util.resource.JarFileResource=ERROR -log4j.logger.org.spark-project.jetty.util.resource.JarResource=ERROR -log4j.logger.org.spark-project.jetty.util.resource.Resource=ERROR -log4j.logger.org.spark-project.jetty.util.resource.URLResource=ERROR -log4j.logger.org.spark-project.jetty.util.StringUtil=ERROR -log4j.logger.org.spark-project.jetty.util.thread.QueuedThreadPool=ERROR -log4j.logger.org.spark-project.jetty.util.thread.Timeout=ERROR -log4j.logger.org.spark-project.jetty=ERROR -log4j.logger.Remoting=ERROR diff --git a/dataset/src/test/scala/frameless/AsTests.scala b/dataset/src/test/scala/frameless/AsTests.scala deleted file mode 100644 index c1091f9ca..000000000 --- a/dataset/src/test/scala/frameless/AsTests.scala +++ /dev/null @@ -1,53 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class AsTests extends TypedDatasetSuite { - test("as[X2[A, B]]") { - def prop[A, B](data: Vector[(A, B)])( - implicit - eab: TypedEncoder[(A, B)], - ex2: TypedEncoder[X2[A, B]] - ): Prop = { - val dataset = TypedDataset.create(data) - - val dataset2 = dataset.as[X2[A,B]]().collect().run().toVector - val data2 = data.map { case (a, b) => X2(a, b) } - - dataset2 ?= data2 - } - - check(forAll(prop[Int, Int] _)) - check(forAll(prop[String, String] _)) - check(forAll(prop[String, Int] _)) - check(forAll(prop[Long, Int] _)) - check(forAll(prop[Seq[Seq[Option[Seq[Long]]]], Seq[Int]] _)) - check(forAll(prop[Seq[Option[Seq[String]]], Seq[Int]] _)) - } - - test("as[X2[X2[A, B], C]") { - def prop[A, B, C](data: Vector[(A, B, C)])( - implicit - eab: TypedEncoder[((A, B), C)], - ex2: TypedEncoder[X2[X2[A, B], C]] - ): Prop = { - val data2 = data.map { - case (a, b, c) => ((a, b), c) - } - val dataset = TypedDataset.create(data2) - - val dataset2 = dataset.as[X2[X2[A,B], C]]().collect().run().toVector - val data3 = data2.map { case ((a, b), c) => X2(X2(a, b), c) } - - dataset2 ?= data3 - } - - check(forAll(prop[String, Int, Int] _)) - check(forAll(prop[String, Int, String] _)) - check(forAll(prop[String, String, Int] _)) - check(forAll(prop[Long, Int, String] _)) - check(forAll(prop[Seq[Seq[Option[Seq[Long]]]], Seq[Int], Option[Seq[Option[Int]]]] _)) - check(forAll(prop[Seq[Option[Seq[String]]], Seq[Int], Seq[Option[String]]] _)) - } -} diff --git a/dataset/src/test/scala/frameless/BitwiseTests.scala b/dataset/src/test/scala/frameless/BitwiseTests.scala deleted file mode 100644 index b83662f69..000000000 --- a/dataset/src/test/scala/frameless/BitwiseTests.scala +++ /dev/null @@ -1,117 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import org.scalatest.matchers.should.Matchers - -class BitwiseTests extends TypedDatasetSuite with Matchers{ - - /** - * providing instances with implementations for bitwise operations since in the tests - * we need to check the results from frameless vs the results from normal scala operators - * for Numeric it is easy to test since scala comes with Numeric typeclass but there seems - * to be no equivalent typeclass for bitwise ops for Byte Short Int and Long types supported in Catalyst - */ - trait CatalystBitwise4Tests[A]{ - def bitwiseAnd(a1: A, a2: A): A - def bitwiseOr(a1: A, a2: A): A - def bitwiseXor(a1: A, a2: A): A - def &(a1: A, a2: A): A = bitwiseAnd(a1, a2) - def |(a1: A, a2: A): A = bitwiseOr(a1, a2) - def ^(a1: A, a2: A): A = bitwiseXor(a1, a2) - } - - object CatalystBitwise4Tests { - implicit val framelessbyteBitwise : CatalystBitwise4Tests[Byte] = new CatalystBitwise4Tests[Byte] { - def bitwiseOr(a1: Byte, a2: Byte) : Byte = (a1 | a2).toByte - def bitwiseAnd(a1: Byte, a2: Byte): Byte = (a1 & a2).toByte - def bitwiseXor(a1: Byte, a2: Byte): Byte = (a1 ^ a2).toByte - } - implicit val framelessshortBitwise : CatalystBitwise4Tests[Short] = new CatalystBitwise4Tests[Short] { - def bitwiseOr(a1: Short, a2: Short) : Short = (a1 | a2).toShort - def bitwiseAnd(a1: Short, a2: Short): Short = (a1 & a2).toShort - def bitwiseXor(a1: Short, a2: Short): Short = (a1 ^ a2).toShort - } - implicit val framelessintBitwise : CatalystBitwise4Tests[Int] = new CatalystBitwise4Tests[Int] { - def bitwiseOr(a1: Int, a2: Int) : Int = a1 | a2 - def bitwiseAnd(a1: Int, a2: Int): Int = a1 & a2 - def bitwiseXor(a1: Int, a2: Int): Int = a1 ^ a2 - } - implicit val framelesslongBitwise : CatalystBitwise4Tests[Long] = new CatalystBitwise4Tests[Long] { - def bitwiseOr(a1: Long, a2: Long) : Long = a1 | a2 - def bitwiseAnd(a1: Long, a2: Long): Long = a1 & a2 - def bitwiseXor(a1: Long, a2: Long): Long = a1 ^ a2 - } - - } - import CatalystBitwise4Tests._ - test("bitwiseAND") { - def prop[A: TypedEncoder: CatalystBitwise](a: A, b: A)( - implicit catalystBitwise4Tests: CatalystBitwise4Tests[A] - ): Prop = { - val df = TypedDataset.create(X2(a, b) :: Nil) - val result = implicitly[CatalystBitwise4Tests[A]].bitwiseAnd(a, b) - val resultSymbolic = implicitly[CatalystBitwise4Tests[A]].&(a, b) - val got = df.select(df.col('a) bitwiseAND df.col('b)).collect().run() - val gotSymbolic = df.select(df.col('a) & b).collect().run() - val symbolicCol2Col = df.select(df.col('a) & df.col('b)).collect().run() - val canCast = df.select(df.col('a).cast[Long] & 0L).collect().run() - canCast should contain theSameElementsAs Seq.fill[Long](gotSymbolic.size)(0L) - result ?= resultSymbolic - symbolicCol2Col ?= (result :: Nil) - got ?= (result :: Nil) - gotSymbolic ?= (resultSymbolic :: Nil) - } - - check(prop[Byte] _) - check(prop[Short] _) - check(prop[Int] _) - check(prop[Long] _) - } - - test("bitwiseOR") { - def prop[A: TypedEncoder: CatalystBitwise](a: A, b: A)( - implicit catalystBitwise4Tests: CatalystBitwise4Tests[A] - ): Prop = { - val df = TypedDataset.create(X2(a, b) :: Nil) - val result = implicitly[CatalystBitwise4Tests[A]].bitwiseOr(a, b) - val resultSymbolic = implicitly[CatalystBitwise4Tests[A]].|(a, b) - val got = df.select(df.col('a) bitwiseOR df.col('b)).collect().run() - val gotSymbolic = df.select(df.col('a) | b).collect().run() - val symbolicCol2Col = df.select(df.col('a) | df.col('b)).collect().run() - val canCast = df.select(df.col('a).cast[Long] | -1L).collect().run() - canCast should contain theSameElementsAs Seq.fill[Long](gotSymbolic.size)(-1L) - result ?= resultSymbolic - symbolicCol2Col ?= (result :: Nil) - got ?= (result :: Nil) - gotSymbolic ?= (resultSymbolic :: Nil) - } - - check(prop[Byte] _) - check(prop[Short] _) - check(prop[Int] _) - check(prop[Long] _) - } - - test("bitwiseXOR") { - def prop[A: TypedEncoder: CatalystBitwise](a: A, b: A)( - implicit catalystBitwise4Tests: CatalystBitwise4Tests[A] - ): Prop = { - val df = TypedDataset.create(X2(a, b) :: Nil) - val result = implicitly[CatalystBitwise4Tests[A]].bitwiseXor(a, b) - val resultSymbolic = implicitly[CatalystBitwise4Tests[A]].^(a, b) - result ?= resultSymbolic - val got = df.select(df.col('a) bitwiseXOR df.col('b)).collect().run() - val gotSymbolic = df.select(df.col('a) ^ b).collect().run() - val zeroes = df.select(df.col('a) ^ df.col('a)).collect().run() - zeroes should contain theSameElementsAs Seq.fill[Long](gotSymbolic.size)(0L) - got ?= (result :: Nil) - gotSymbolic ?= (resultSymbolic :: Nil) - } - - check(prop[Byte] _) - check(prop[Short] _) - check(prop[Int] _) - check(prop[Long] _) - } -} diff --git a/dataset/src/test/scala/frameless/CastTests.scala b/dataset/src/test/scala/frameless/CastTests.scala deleted file mode 100644 index 5f79f8fa6..000000000 --- a/dataset/src/test/scala/frameless/CastTests.scala +++ /dev/null @@ -1,111 +0,0 @@ -package frameless - -import org.scalacheck.{Arbitrary, Gen, Prop} -import org.scalacheck.Prop._ - -class CastTests extends TypedDatasetSuite { - - def prop[A: TypedEncoder, B: TypedEncoder](f: A => B)(a: A)( - implicit - cast: CatalystCast[A, B] - ): Prop = { - val df = TypedDataset.create(X1(a) :: Nil) - val got = df.select(df.col('a).cast[B]).collect().run() - - got ?= (f(a) :: Nil) - } - - test("cast") { - // numericToDecimal - check(prop[BigDecimal, BigDecimal](identity) _) - check(prop[Byte, BigDecimal](x => BigDecimal.valueOf(x.toLong)) _) - check(prop[Double, BigDecimal](BigDecimal.valueOf) _) - check(prop[Int, BigDecimal](x => BigDecimal.valueOf(x.toLong)) _) - check(prop[Long, BigDecimal](BigDecimal.valueOf) _) - check(prop[Short, BigDecimal](x => BigDecimal.valueOf(x.toLong)) _) - - // numericToByte - check(prop[BigDecimal, Byte](_.toByte) _) - check(prop[Byte, Byte](identity) _) - check(prop[Double, Byte](_.toByte) _) - check(prop[Int, Byte](_.toByte) _) - check(prop[Long, Byte](_.toByte) _) - check(prop[Short, Byte](_.toByte) _) - - // numericToDouble - check(prop[BigDecimal, Double](_.toDouble) _) - check(prop[Byte, Double](_.toDouble) _) - check(prop[Double, Double](identity) _) - check(prop[Int, Double](_.toDouble) _) - check(prop[Long, Double](_.toDouble) _) - check(prop[Short, Double](_.toDouble) _) - - // numericToInt - check(prop[BigDecimal, Int](_.toInt) _) - check(prop[Byte, Int](_.toInt) _) - check(prop[Double, Int](_.toInt) _) - check(prop[Int, Int](identity) _) - check(prop[Long, Int](_.toInt) _) - check(prop[Short, Int](_.toInt) _) - - // numericToLong - check(prop[BigDecimal, Long](_.toLong) _) - check(prop[Byte, Long](_.toLong) _) - check(prop[Double, Long](_.toLong) _) - check(prop[Int, Long](_.toLong) _) - check(prop[Long, Long](identity) _) - check(prop[Short, Long](_.toLong) _) - - // numericToShort - check(prop[BigDecimal, Short](_.toShort) _) - check(prop[Byte, Short](_.toShort) _) - check(prop[Double, Short](_.toShort) _) - check(prop[Int, Short](_.toShort) _) - check(prop[Long, Short](_.toShort) _) - check(prop[Short, Short](identity) _) - - // castToString - // TODO compare without trailing zeros - // check(prop[BigDecimal, String](_.toString()) _) - check(prop[Byte, String](_.toString) _) - check(prop[Double, String](_.toString) _) - check(prop[Int, String](_.toString) _) - check(prop[Long, String](_.toString) _) - check(prop[Short, String](_.toString) _) - - // stringToBoolean - val trueStrings = Set("t", "true", "y", "yes", "1") - val falseStrings = Set("f", "false", "n", "no", "0") - - def stringToBoolean(str: String): Option[Boolean] = { - if (trueStrings(str)) Some(true) - else if (falseStrings(str)) Some(false) - else None - } - - val stringToBooleanGen = Gen.oneOf( - Gen.oneOf(trueStrings.toSeq), - Gen.oneOf(falseStrings.toSeq), - Arbitrary.arbitrary[String] - ) - - check(forAll(stringToBooleanGen)(prop(stringToBoolean))) - - // xxxToBoolean - check(prop[BigDecimal, Boolean](_ != BigDecimal(0)) _) - check(prop[Byte, Boolean](_ != 0) _) - check(prop[Double, Boolean](_ != 0) _) - check(prop[Int, Boolean](_ != 0) _) - check(prop[Long, Boolean](_ != 0L) _) - check(prop[Short, Boolean](_ != 0) _) - - // booleanToNumeric - check(prop[Boolean, BigDecimal](x => if (x) BigDecimal(1) else BigDecimal(0)) _) - check(prop[Boolean, Byte](x => if (x) 1 else 0) _) - check(prop[Boolean, Double](x => if (x) 1.0f else 0.0f) _) - check(prop[Boolean, Int](x => if (x) 1 else 0) _) - check(prop[Boolean, Long](x => if (x) 1L else 0L) _) - check(prop[Boolean, Short](x => if (x) 1 else 0) _) - } - -} diff --git a/dataset/src/test/scala/frameless/ColTests.scala b/dataset/src/test/scala/frameless/ColTests.scala deleted file mode 100644 index ad62aa068..000000000 --- a/dataset/src/test/scala/frameless/ColTests.scala +++ /dev/null @@ -1,57 +0,0 @@ -package frameless - -import shapeless.test.illTyped - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class ColTests extends TypedDatasetSuite { - test("col") { - val x4 = TypedDataset.create[X4[Int, String, Long, Boolean]](Nil) - val t4 = TypedDataset.create[(Int, String, Long, Boolean)](Nil) - - x4.col('a) - t4.col('_1) - - x4.col[Int]('a) - t4.col[Int]('_1) - - illTyped("x4.col[String]('a)", "No column .* of type String in frameless.X4.*") - - x4.col('b) - t4.col('_2) - - x4.col[String]('b) - t4.col[String]('_2) - - illTyped("x4.col[Int]('b)", "No column .* of type Int in frameless.X4.*") - - () - } - - test("colMany") { - type X2X2 = X2[X2[Int, String], X2[Long, Boolean]] - val x2x2 = TypedDataset.create[X2X2](Nil) - - val aa: TypedColumn[X2X2, Int] = x2x2.colMany('a, 'a) - val ab: TypedColumn[X2X2, String] = x2x2.colMany('a, 'b) - val ba: TypedColumn[X2X2, Long] = x2x2.colMany('b, 'a) - val bb: TypedColumn[X2X2, Boolean] = x2x2.colMany('b, 'b) - - illTyped("x2x2.colMany('a, 'c)") - illTyped("x2x2.colMany('a, 'a, 'a)") - } - - test("select colMany") { - def prop[A: TypedEncoder](x: X2[X2[A, A], A]): Prop = { - val df = TypedDataset.create(x :: Nil) - val got = df.select(df.colMany('a, 'a)).collect().run() - - got ?= (x.a.a :: Nil) - } - - check(prop[Int] _) - check(prop[X2[Int, Int]] _) - check(prop[X2[X2[Int, Int], Int]] _) - } -} diff --git a/dataset/src/test/scala/frameless/CollectTests.scala b/dataset/src/test/scala/frameless/CollectTests.scala deleted file mode 100644 index 5874312c9..000000000 --- a/dataset/src/test/scala/frameless/CollectTests.scala +++ /dev/null @@ -1,94 +0,0 @@ -package frameless - -import frameless.CollectTests.{ prop, propArray } -import org.apache.spark.sql.SparkSession -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import scala.reflect.ClassTag - -class CollectTests extends TypedDatasetSuite { - test("collect()") { - check(forAll(propArray[Int] _)) - check(forAll(propArray[Long] _)) - check(forAll(propArray[Boolean] _)) - check(forAll(propArray[Float] _)) - check(forAll(propArray[String] _)) - check(forAll(propArray[Byte] _)) - check(forAll(propArray[Option[Int]] _)) - check(forAll(propArray[Option[Long]] _)) - check(forAll(propArray[Option[Double]] _)) - check(forAll(propArray[Option[Float]] _)) - check(forAll(propArray[Option[Short]] _)) - check(forAll(propArray[Option[Byte]] _)) - check(forAll(propArray[Option[Boolean]] _)) - check(forAll(propArray[Option[String]] _)) - - check(forAll(prop[X2[Int, Int]] _)) - check(forAll(prop[X2[String, String]] _)) - check(forAll(prop[X2[String, Int]] _)) - check(forAll(prop[X2[Long, Int]] _)) - - check(forAll(prop[X2[X2[Int, String], Boolean]] _)) - check(forAll(prop[Tuple1[Option[Int]]] _)) - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Double] _)) - check(forAll(prop[Float] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Char] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Boolean] _)) - check(forAll(prop[String] _)) - check(forAll(prop[SQLDate] _)) - check(forAll(prop[SQLTimestamp] _)) - check(forAll(prop[Option[Int]] _)) - check(forAll(prop[Option[Long]] _)) - check(forAll(prop[Option[Double]] _)) - check(forAll(prop[Option[Float]] _)) - check(forAll(prop[Option[Short]] _)) - check(forAll(prop[Option[Byte]] _)) - check(forAll(prop[Option[Boolean]] _)) - check(forAll(prop[Option[String]] _)) - check(forAll(prop[Option[SQLDate]] _)) - check(forAll(prop[Option[SQLTimestamp]] _)) - - check(forAll(prop[Vector[Int]] _)) - check(forAll(prop[List[Int]] _)) - check(forAll(prop[Seq[Int]] _)) - check(forAll(prop[Vector[Char]] _)) - check(forAll(prop[List[Char]] _)) - check(forAll(prop[Seq[Char]] _)) - check(forAll(prop[Seq[Seq[Seq[Char]]]] _)) - check(forAll(prop[Seq[Option[String]]] _)) - check(forAll(prop[Seq[Map[String, Long]]] _)) - check(forAll(prop[Seq[Map[String, X2[Option[Long], Vector[Boolean]]]]] _)) - check(forAll(prop[Option[Int]] _)) - check(forAll(prop[Vector[X2[Int, Int]]] _)) - - check(forAll(prop[X1[Vector[Food]]] _)) - check(forAll(prop[X1[Vector[X1[Food]]]] _)) - check(forAll(prop[X1[Vector[X1[Int]]]] _)) - - // TODO this doesn't work, and never worked... - // check(forAll(prop[X1[Option[X1[Option[Int]]]]] _)) - - check(forAll(prop[UdtEncodedClass] _)) - check(forAll(prop[Option[UdtEncodedClass]] _)) - check(forAll(prop[X1[UdtEncodedClass]] _)) - check(forAll(prop[X2[Int, UdtEncodedClass]] _)) - check(forAll(prop[(Long, UdtEncodedClass)] _)) - } -} - -object CollectTests { - import frameless.syntax._ - - def prop[A: TypedEncoder : ClassTag](data: Vector[A])(implicit c: SparkSession): Prop = - TypedDataset.create(data).collect().run().toVector ?= data - - def propArray[A: TypedEncoder : ClassTag](data: Vector[X1[Array[A]]])(implicit c: SparkSession): Prop = - Prop(TypedDataset.create(data).collect().run().toVector.zip(data).forall { - case (X1(l), X1(r)) => l.sameElements(r) - }) -} diff --git a/dataset/src/test/scala/frameless/ColumnTests.scala b/dataset/src/test/scala/frameless/ColumnTests.scala deleted file mode 100644 index 58ff98dac..000000000 --- a/dataset/src/test/scala/frameless/ColumnTests.scala +++ /dev/null @@ -1,428 +0,0 @@ -package frameless - -import java.time.Instant - -import org.scalacheck.Prop._ -import org.scalacheck.{Arbitrary, Gen, Prop}, Arbitrary.arbitrary -import org.scalatest.matchers.should.Matchers -import shapeless.test.illTyped -import ceedubs.irrec.regex.gen.CharRegexGen.genCharRegexAndCandidate - -import scala.math.Ordering.Implicits._ - -class ColumnTests extends TypedDatasetSuite with Matchers { - - private implicit object OrderingImplicits { - implicit val sqlDateOrdering: Ordering[SQLDate] = Ordering.by(_.days) - implicit val sqlTimestmapOrdering: Ordering[SQLTimestamp] = Ordering.by(_.us) - implicit val arbInstant: Arbitrary[Instant] = Arbitrary( - Gen.chooseNum(0L, Instant.MAX.getEpochSecond) - .map(Instant.ofEpochSecond)) - implicit val instantAsLongInjection: Injection[Instant, Long] = - Injection(_.getEpochSecond, Instant.ofEpochSecond) - } - - test("select('a < 'b, 'a <= 'b, 'a > 'b, 'a >= 'b)") { - import OrderingImplicits._ - def prop[A: TypedEncoder : CatalystOrdered : Ordering](a: A, b: A): Prop = { - val dataset = TypedDataset.create(X2(a, b) :: Nil) - val A = dataset.col('a) - val B = dataset.col('b) - - val dataset2 = dataset.selectMany( - A < B, A < b, // One test uses columns, other uses literals - A <= B, A <= b, - A > B, A > b, - A >= B, A >= b - ).collect().run().toVector - - dataset2 ?= Vector((a < b, a < b, a <= b, a <= b, a > b, a > b, a >= b, a >= b)) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Boolean] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Float] _)) - check(forAll(prop[Double] _)) - check(forAll(prop[SQLDate] _)) - check(forAll(prop[SQLTimestamp] _)) - check(forAll(prop[String] _)) - check(forAll(prop[Instant] _)) - } - - test("between") { - import OrderingImplicits._ - def prop[A: TypedEncoder : CatalystOrdered : Ordering](a: A, b: A, c: A): Prop = { - val dataset = TypedDataset.create(X3(a, b, c) :: Nil) - val A = dataset.col('a) - val B = dataset.col('b) - val C = dataset.col('c) - - val isBetweeen = dataset.selectMany(A.between(B, C), A.between(b, c)).collect().run().toVector - val result = b <= a && a <= c - - isBetweeen ?= Vector((result, result)) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Boolean] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Float] _)) - check(forAll(prop[Double] _)) - check(forAll(prop[SQLDate] _)) - check(forAll(prop[SQLTimestamp] _)) - check(forAll(prop[String] _)) - check(forAll(prop[Instant] _)) - } - - test("toString") { - val t = TypedDataset.create((1, 2) :: Nil) - t('_1).toString ?= t.dataset.col("_1").toString() - } - - test("boolean and / or") { - val spark = session - import spark.implicits._ - - check { - forAll { (s: Seq[X3[Boolean, Boolean, Boolean]]) => - val ds = TypedDataset.create(s) - - val typedBoolean = ds.select( - ds('a) && ds('b) || ds('c), - ds('a).and(ds('b)).or(ds('c)) - ).collect().run().toList - - val untypedDs = ds.toDF() - val untypedBoolean = untypedDs.select( - untypedDs("a") && untypedDs("b") || untypedDs("c"), - untypedDs("a").and(untypedDs("b")).or(untypedDs("c")) - ).as[(Boolean, Boolean)].collect().toList - - typedBoolean ?= untypedBoolean - } - } - } - - test("substr") { - val spark = session - import spark.implicits._ - - check { - forAll { (a: String, b: Int, c: Int) => - val ds = TypedDataset.create(X3(a, b, c) :: Nil) - - val typedSubstr = ds - .select(ds('a).substr(ds('b), ds('c))) - .collect() - .run() - .toList - - val untypedDs = ds.toDF() - val untypedSubstr = untypedDs - .select(untypedDs("a").substr(untypedDs("b"), untypedDs("c"))) - .as[String] - .collect() - .toList - - typedSubstr ?= untypedSubstr - } - } - - check { - forAll { (a: String, b: Int, c: Int) => - val ds = TypedDataset.create(X1(a) :: Nil) - - val typedSubstr = ds - .select(ds('a).substr(b, c)) - .collect() - .run() - .toList - - val untypedDs = ds.toDF() - val untypedSubstr = untypedDs - .select(untypedDs("a").substr(b, c)) - .as[String] - .collect() - .toList - - typedSubstr ?= untypedSubstr - } - } - - val ds1 = TypedDataset.create((1, false, 2.0) :: Nil) - illTyped("""ds1.select(ds1('_1).substr(0, 5))""") - illTyped("""ds1.select(ds1('_2).substr(0, 5))""") - illTyped("""ds1.select(ds1('_3).substr(0, 5))""") - illTyped("""ds1.select(ds1('_1).substr(ds1('_2), ds1('_3)))""") - } - - test("like") { - val spark = session - import spark.implicits._ - - check { - forAll { (a: String, b: String) => - val ds = TypedDataset.create(X2(a, b) :: Nil) - - val typedLike = ds - .select(ds('a).like(a), ds('b).like(a)) - .collect() - .run() - .toList - - val untypedDs = ds.toDF() - val untypedLike = untypedDs - .select(untypedDs("a").like(a), untypedDs("b").like(a)) - .as[(Boolean, Boolean)] - .collect() - .toList - - typedLike ?= untypedLike - } - } - - val ds = TypedDataset.create((1, false, 2.0) :: Nil) - illTyped("""ds.select(ds('_1).like("foo"))""") - illTyped("""ds.select(ds('_2).like("foo"))""") - illTyped("""ds.select(ds('_3).like("foo"))""") - } - - test("rlike") { - val spark = session - import spark.implicits._ - - check { - forAll(genCharRegexAndCandidate[Char], arbitrary[String]) { (r, b) => - val a = r.candidate.mkString - val ds = TypedDataset.create(X2(a, b) :: Nil) - - val typedLike = ds - .select(ds('a).rlike(r.r.pprint), ds('b).rlike(r.r.pprint), ds('a).rlike(".*")) - .collect() - .run() - .toList - - val untypedDs = ds.toDF() - val untypedLike = untypedDs - .select(untypedDs("a").rlike(r.r.pprint), untypedDs("b").rlike(r.r.pprint), untypedDs("a").rlike(".*")) - .as[(Boolean, Boolean, Boolean)] - .collect() - .toList - - (typedLike ?= untypedLike) - } - } - - val ds = TypedDataset.create((1, false, 2.0) :: Nil) - illTyped("""ds.select(ds('_1).rlike("foo"))""") - illTyped("""ds.select(ds('_2).rlike("foo"))""") - illTyped("""ds.select(ds('_3).rlike("foo"))""") - } - - test("contains") { - val spark = session - import spark.implicits._ - - check { - forAll { (a: String, b: String) => - val ds = TypedDataset.create(X2(a, b) :: Nil) - - val typedContains = ds - .select(ds('a).contains(ds('b)), ds('b).contains(a)) - .collect() - .run() - .toList - - val untypedDs = ds.toDF() - val untypedContains = untypedDs - .select(untypedDs("a").contains(untypedDs("b")), untypedDs("b").contains(a)) - .as[(Boolean, Boolean)] - .collect() - .toList - - typedContains ?= untypedContains - } - } - - val ds = TypedDataset.create((1, false, 2.0) :: Nil) - illTyped("""ds.select(ds('_1).contains("foo"))""") - illTyped("""ds.select(ds('_2).contains("foo"))""") - illTyped("""ds.select(ds('_3).contains("foo"))""") - } - - test("startsWith") { - val spark = session - import spark.implicits._ - - check { - forAll { (a: String, b: String) => - val ds = TypedDataset.create(X2(a, b) :: Nil) - - val typedStartsWith = ds - .select(ds('a).startsWith(ds('b)), ds('b).startsWith(a)) - .collect() - .run() - .toList - - val untypedDs = ds.toDF() - val untypedStartsWith = untypedDs - .select(untypedDs("a").startsWith(untypedDs("b")), untypedDs("b").startsWith(a)) - .as[(Boolean, Boolean)] - .collect() - .toList - - typedStartsWith ?= untypedStartsWith - } - } - - val ds = TypedDataset.create((1, false, 2.0) :: Nil) - illTyped("""ds.select(ds('_1).startsWith("foo"))""") - illTyped("""ds.select(ds('_2).startsWith("foo"))""") - illTyped("""ds.select(ds('_3).startsWith("foo"))""") - } - - test("endsWith") { - val spark = session - import spark.implicits._ - - check { - forAll { (a: String, b: String) => - val ds = TypedDataset.create(X2(a, b) :: Nil) - val typedStartsWith = ds - .select(ds('a).endsWith(ds('b)), ds('b).endsWith(a)) - .collect() - .run() - .toList - - val untypedDs = ds.toDF() - val untypedStartsWith = untypedDs - .select(untypedDs("a").endsWith(untypedDs("b")), untypedDs("b").endsWith(a)) - .as[(Boolean, Boolean)] - .collect() - .toList - - typedStartsWith ?= untypedStartsWith - } - } - - val ds = TypedDataset.create((1, false, 2.0) :: Nil) - illTyped("""ds.select(ds('_1).endsWith("foo"))""") - illTyped("""ds.select(ds('_2).endsWith("foo"))""") - illTyped("""ds.select(ds('_3).endsWith("foo"))""") - } - - test("getOrElse") { - def prop[A: TypedEncoder](a: A, opt: Option[A]) = { - val dataset = TypedDataset.create(X2(a, opt) :: Nil) - - val defaulted: (A, A) = dataset - .select(dataset('b).getOrElse(dataset('a)), dataset('b).getOrElse(a)) - .collect() - .run() - .toList - .head - - defaulted.?=((opt.getOrElse(a), opt.getOrElse(a))) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Boolean] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Float] _)) - check(forAll(prop[Double] _)) - check(forAll(prop[SQLDate] _)) - check(forAll(prop[SQLTimestamp] _)) - check(forAll(prop[String] _)) - } - - test("asCol") { - def prop[A: TypedEncoder, B: TypedEncoder](a: Seq[X2[A, B]]) = { - val ds: TypedDataset[X2[A, B]] = TypedDataset.create(a) - - val frameless: Seq[(A, X2[A, B], X2[A, B], X2[A, B], B)] = - ds.select(ds('a), ds.asCol, ds.asCol, ds.asCol, ds('b)).collect().run() - - val scala: Seq[(A, X2[A, B], X2[A, B], X2[A, B], B)] = - a.map(x => (x.a, x, x, x, x.b)) - - scala ?= frameless - } - - check(forAll(prop[Int, Option[Long]] _)) - check(forAll(prop[Vector[Char], Option[Boolean]] _)) - check(forAll(prop[Vector[Vector[String]], Vector[Vector[BigDecimal]]] _)) - } - - test("asCol single column TypedDatasets") { - def prop[A: TypedEncoder](a: Seq[A]) = { - val ds: TypedDataset[A] = TypedDataset.create(a) - - val frameless: Seq[(A, A, A)] = - ds.select(ds.asCol, ds.asCol, ds.asCol).collect().run() - - val scala: Seq[(A, A, A)] = - a.map(x => (x, x, x)) - - scala ?= frameless - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Vector[Vector[String]]] _)) - } - - test("asCol with numeric operators") { - def prop(a: Seq[Long]) = { - val ds: TypedDataset[Long] = TypedDataset.create(a) - val (first,second) = (2L,5L) - val frameless: Seq[(Long, Long, Long)] = - ds.select(ds.asCol, ds.asCol+first, ds.asCol*second).collect().run() - - val scala: Seq[(Long, Long, Long)] = - a.map(x => (x, x+first, x*second)) - - scala ?= frameless - } - - check(forAll(prop _)) - } - - test("unary_!") { - val ds = TypedDataset.create((true, false) :: Nil) - - val rs = ds.select(!ds('_1), !ds('_2)).collect().run().head - val expected = (false, true) - - rs shouldEqual expected - } - - test("unary_! with non-boolean columns should not compile") { - val ds = TypedDataset.create((1, "a", 2.0) :: Nil) - - "ds.select(!ds('_1))" shouldNot typeCheck - "ds.select(!ds('_2))" shouldNot typeCheck - "ds.select(!ds('_3))" shouldNot typeCheck - } - - test("opt") { - val data = (Option(1L), Option(2L)) :: (None, None) :: Nil - val ds = TypedDataset.create(data) - val rs = ds.select(ds('_1).opt.map(_ * 2), ds('_1).opt.map(_ + 2)).collect().run() - val expected = data.map { case (x, y) => (x.map(_ * 2), y.map(_ + 1)) } - rs shouldEqual expected - } - - test("opt compiles only for columns of type Option[_]") { - val ds = TypedDataset.create((1, List(1,2,3)) :: Nil) - "ds.select(ds('_1).opt.map(x => x))" shouldNot typeCheck - "ds.select(ds('_2).opt.map(x => x))" shouldNot typeCheck - } -} diff --git a/dataset/src/test/scala/frameless/CreateTests.scala b/dataset/src/test/scala/frameless/CreateTests.scala deleted file mode 100644 index 9282aa8b0..000000000 --- a/dataset/src/test/scala/frameless/CreateTests.scala +++ /dev/null @@ -1,153 +0,0 @@ -package frameless - -import org.scalacheck.{Arbitrary, Prop} -import org.scalacheck.Prop._ - -import scala.reflect.ClassTag -import shapeless.test.illTyped -import org.scalatest.matchers.should.Matchers - -class CreateTests extends TypedDatasetSuite with Matchers { - - import TypedEncoder.usingInjection - - test("creation using X4 derived DataFrames") { - def prop[ - A: TypedEncoder, - B: TypedEncoder, - C: TypedEncoder, - D: TypedEncoder](data: Vector[X4[A, B, C, D]]): Prop = { - val ds = TypedDataset.create(data) - TypedDataset.createUnsafe[X4[A, B, C, D]](ds.toDF()).collect().run() ?= data - } - - check(forAll(prop[Int, Char, X2[Option[Country], Country], Int] _)) - check(forAll(prop[X2[Int, Int], Int, Boolean, Vector[Food]] _)) - check(forAll(prop[String, Food, X3[Food, Country, Boolean], Int] _)) - check(forAll(prop[String, Food, X3U[Food, Country, Boolean], Int] _)) - check(forAll(prop[ - Option[Vector[Food]], - Vector[Vector[X2[Vector[(Person, X1[Char])], Country]]], - X3[Food, Country, String], - Vector[(Food, Country)]] _)) - } - - test("array fields") { - def prop[T: Arbitrary: TypedEncoder: ClassTag] = forAll { - (d1: Array[T], d2: Array[Option[T]], d3: Array[X1[T]], d4: Array[X1[Option[T]]], - d5: X1[Array[T]]) => - TypedDataset.create(Seq(d1)).collect().run().head.sameElements(d1) && - TypedDataset.create(Seq(d2)).collect().run().head.sameElements(d2) && - TypedDataset.create(Seq(d3)).collect().run().head.sameElements(d3) && - TypedDataset.create(Seq(d4)).collect().run().head.sameElements(d4) && - TypedDataset.create(Seq(d5)).collect().run().head.a.sameElements(d5.a) - } - - check(prop[Boolean]) - check(prop[Byte]) - check(prop[Short]) - check(prop[Int]) - check(prop[Long]) - check(prop[Float]) - check(prop[Double]) - check(prop[String]) - } - - test("vector fields") { - def prop[T: Arbitrary: TypedEncoder] = forAll { - (d1: Vector[T], d2: Vector[Option[T]], d3: Vector[X1[T]], d4: Vector[X1[Option[T]]], - d5: X1[Vector[T]]) => - (TypedDataset.create(Seq(d1)).collect().run().head ?= d1) && - (TypedDataset.create(Seq(d2)).collect().run().head ?= d2) && - (TypedDataset.create(Seq(d3)).collect().run().head ?= d3) && - (TypedDataset.create(Seq(d4)).collect().run().head ?= d4) && - (TypedDataset.create(Seq(d5)).collect().run().head ?= d5) - } - - check(prop[Boolean]) - check(prop[Byte]) - check(prop[Char]) - check(prop[Short]) - check(prop[Int]) - check(prop[Long]) - check(prop[Float]) - check(prop[Double]) - check(prop[String]) - } - - test("list fields") { - def prop[T: Arbitrary: TypedEncoder] = forAll { - (d1: List[T], d2: List[Option[T]], d3: List[X1[T]], d4: List[X1[Option[T]]], - d5: X1[List[T]]) => - (TypedDataset.create(Seq(d1)).collect().run().head ?= d1) && - (TypedDataset.create(Seq(d2)).collect().run().head ?= d2) && - (TypedDataset.create(Seq(d3)).collect().run().head ?= d3) && - (TypedDataset.create(Seq(d4)).collect().run().head ?= d4) && - (TypedDataset.create(Seq(d5)).collect().run().head ?= d5) - } - - check(prop[Boolean]) - check(prop[Byte]) - check(prop[Char]) - check(prop[Short]) - check(prop[Int]) - check(prop[Long]) - check(prop[Float]) - check(prop[Double]) - check(prop[String]) - } - - test("map fields (scala.Predef.Map / scala.collection.immutable.Map)") { - def prop[A: Arbitrary: TypedEncoder, B: Arbitrary: TypedEncoder] = forAll { - (d1: Map[A, B], d2: Map[B, A], d3: Map[A, Option[B]], - d4: Map[A, X1[B]], d5: Map[X1[A], B], d6: Map[X1[A], X1[B]]) => - - (TypedDataset.create(Seq(d1)).collect().run().head ?= d1) && - (TypedDataset.create(Seq(d2)).collect().run().head ?= d2) && - (TypedDataset.create(Seq(d3)).collect().run().head ?= d3) && - (TypedDataset.create(Seq(d4)).collect().run().head ?= d4) && - (TypedDataset.create(Seq(d5)).collect().run().head ?= d5) && - (TypedDataset.create(Seq(d6)).collect().run().head ?= d6) - } - - check(prop[String, String]) - check(prop[String, Boolean]) - check(prop[String, Byte]) - check(prop[String, Char]) - check(prop[String, Short]) - check(prop[String, Int]) - check(prop[String, Long]) - check(prop[String, Float]) - check(prop[String, Double]) - } - - test("maps with Option keys should not resolve the TypedEncoder") { - val data: Seq[Map[Option[Int], Int]] = Seq(Map(Some(5) -> 5)) - illTyped("TypedDataset.create(data)", ".*could not find implicit value for parameter encoder.*") - } - - test("not aligned columns should throw an exception") { - val v = Vector(X2(1,2)) - val df = TypedDataset.create(v).dataset.toDF() - - a [IllegalStateException] should be thrownBy { - TypedDataset.createUnsafe[X1[Int]](df).show().run() - } - } - - test("dataset with different column order") { - // e.g. when loading data from partitioned dataset - // the partition columns get appended to the end of the underlying relation - def prop[A: Arbitrary: TypedEncoder, B: Arbitrary: TypedEncoder] = forAll { - (a1: A, b1: B) => { - val ds = TypedDataset.create( - Vector((b1, a1)) - ).dataset.toDF("b", "a").as[X2[A, B]](TypedExpressionEncoder[X2[A, B]]) - TypedDataset.create(ds).collect().run().head ?= X2(a1, b1) - - } - } - check(prop[X1[Double], X1[X1[SQLDate]]]) - check(prop[String, Int]) - } -} diff --git a/dataset/src/test/scala/frameless/DropTest.scala b/dataset/src/test/scala/frameless/DropTest.scala deleted file mode 100644 index 3e5a0d739..000000000 --- a/dataset/src/test/scala/frameless/DropTest.scala +++ /dev/null @@ -1,63 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import shapeless.test.illTyped - -class DropTest extends TypedDatasetSuite { - import DropTest._ - - test("fail to compile on missing value") { - val f: TypedDataset[X] = TypedDataset.create(X(1, 1, false) :: X(1, 1, false) :: X(1, 10, false) :: Nil) - illTyped { - """val fNew: TypedDataset[XMissing] = f.drop[XMissing]('j)""" - } - } - - test("fail to compile on different column name") { - val f: TypedDataset[X] = TypedDataset.create(X(1, 1, false) :: X(1, 1, false) :: X(1, 10, false) :: Nil) - illTyped { - """val fNew: TypedDataset[XDifferentColumnName] = f.drop[XDifferentColumnName]('j)""" - } - } - - test("fail to compile on added column name") { - val f: TypedDataset[X] = TypedDataset.create(X(1, 1, false) :: X(1, 1, false) :: X(1, 10, false) :: Nil) - illTyped { - """val fNew: TypedDataset[XAdded] = f.drop[XAdded]('j)""" - } - } - - test("remove column in the middle") { - val f: TypedDataset[X] = TypedDataset.create(X(1, 1, false) :: X(1, 1, false) :: X(1, 10, false) :: Nil) - val fNew: TypedDataset[XGood] = f.drop[XGood] - - fNew.collect().run().foreach(xg => assert(xg === XGood(1, false))) - } - - test("drop four columns") { - def prop[A: TypedEncoder](value: A): Prop = { - val d5 = TypedDataset.create(X5(value, value, value, value, value) :: Nil) - val d4 = d5.drop[X4[A, A, A, A]] - val d3 = d4.drop[X3[A, A, A]] - val d2 = d3.drop[X2[A, A]] - val d1 = d2.drop[X1[A]] - - X1(value) ?= d1.collect().run().head - } - - check(prop[Int] _) - check(prop[Long] _) - check(prop[String] _) - check(prop[SQLDate] _) - check(prop[Option[X1[Boolean]]] _) - } -} - -object DropTest { - case class X(i: Int, j: Int, k: Boolean) - case class XMissing(i: Int) - case class XDifferentColumnName(ij: Int, k: Boolean) - case class XAdded(i: Int, j: Int, k: Boolean, l: Int) - case class XGood(i: Int, k: Boolean) -} diff --git a/dataset/src/test/scala/frameless/DropTupledTest.scala b/dataset/src/test/scala/frameless/DropTupledTest.scala deleted file mode 100644 index ff0158b91..000000000 --- a/dataset/src/test/scala/frameless/DropTupledTest.scala +++ /dev/null @@ -1,69 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class DropTupledTest extends TypedDatasetSuite { - test("drop five columns") { - def prop[A: TypedEncoder](value: A): Prop = { - val d5 = TypedDataset.create(X5(value, value, value, value, value) :: Nil) - val d4 = d5.dropTupled('a) //drops first column - val d3 = d4.dropTupled('_4) //drops last column - val d2 = d3.dropTupled('_2) //drops middle column - val d1 = d2.dropTupled('_2) - - Tuple1(value) ?= d1.collect().run().head - } - - check(prop[Int] _) - check(prop[Long] _) - check(prop[String] _) - check(prop[SQLDate] _) - check(prop[Option[X1[Boolean]]] _) - } - - test("drop first column") { - def prop[A: TypedEncoder](value: A): Prop = { - val d3 = TypedDataset.create(X3(value, value, value) :: Nil) - val d2 = d3.dropTupled('a) - - (value, value) ?= d2.collect().run().head - } - - check(prop[Int] _) - check(prop[Long] _) - check(prop[String] _) - check(prop[SQLDate] _) - check(prop[Option[X1[Boolean]]] _) - } - - test("drop middle column") { - def prop[A: TypedEncoder](value: A): Prop = { - val d3 = TypedDataset.create(X3(value, value, value) :: Nil) - val d2 = d3.dropTupled('b) - - (value, value) ?= d2.collect().run().head - } - - check(prop[Int] _) - check(prop[Long] _) - check(prop[String] _) - check(prop[SQLDate] _) - check(prop[Option[X1[Boolean]]] _) - } - - test("drop last column") { - def prop[A: TypedEncoder](value: A): Prop = { - val d3 = TypedDataset.create(X3(value, value, value) :: Nil) - val d2 = d3.dropTupled('c) - - (value, value) ?= d2.collect().run().head - } - - check(prop[Int] _) - check(prop[Long] _) - check(prop[String] _) - check(prop[SQLDate] _) - check(prop[Option[X1[Boolean]]] _) - } -} diff --git a/dataset/src/test/scala/frameless/EncoderTests.scala b/dataset/src/test/scala/frameless/EncoderTests.scala deleted file mode 100644 index dc8a47a69..000000000 --- a/dataset/src/test/scala/frameless/EncoderTests.scala +++ /dev/null @@ -1,15 +0,0 @@ -package frameless - -import org.scalatest.matchers.should.Matchers - -object EncoderTests { - case class Foo(s: Seq[(Int, Int)]) -} - -class EncoderTests extends TypedDatasetSuite with Matchers { - import EncoderTests._ - - test("It should encode deeply nested collections") { - implicitly[TypedEncoder[Seq[Foo]]] - } -} diff --git a/dataset/src/test/scala/frameless/ExplodeTests.scala b/dataset/src/test/scala/frameless/ExplodeTests.scala deleted file mode 100644 index 7e5031588..000000000 --- a/dataset/src/test/scala/frameless/ExplodeTests.scala +++ /dev/null @@ -1,51 +0,0 @@ -package frameless - -import frameless.functions.CatalystExplodableCollection -import org.scalacheck.{Arbitrary, Prop} -import org.scalacheck.Prop.forAll -import org.scalacheck.Prop._ - -import scala.reflect.ClassTag - - -class ExplodeTests extends TypedDatasetSuite { - test("simple explode test") { - val ds = TypedDataset.create(Seq((1,Array(1,2)))) - ds.explode('_2): TypedDataset[(Int,Int)] - } - - test("explode on vectors/list/seq") { - def prop[F[X] <: Traversable[X] : CatalystExplodableCollection, A: TypedEncoder](xs: List[X1[F[A]]])(implicit arb: Arbitrary[F[A]], enc: TypedEncoder[F[A]]): Prop = { - val tds = TypedDataset.create(xs) - - val framelessResults = tds.explode('a).collect().run().toVector - val scalaResults = xs.flatMap(_.a).map(Tuple1(_)).toVector - - framelessResults ?= scalaResults - } - - check(forAll(prop[Vector, Long] _)) - check(forAll(prop[Seq, Int] _)) - check(forAll(prop[Vector, Char] _)) - check(forAll(prop[Vector, String] _)) - check(forAll(prop[List, Long] _)) - check(forAll(prop[List, Int] _)) - check(forAll(prop[List, Char] _)) - check(forAll(prop[List, String] _)) - } - - test("explode on arrays") { - def prop[A: TypedEncoder: ClassTag](xs: List[X1[Array[A]]]): Prop = { - val tds = TypedDataset.create(xs) - - val framelessResults = tds.explode('a).collect().run().toVector - val scalaResults = xs.flatMap(_.a).map(Tuple1(_)).toVector - - framelessResults ?= scalaResults - } - - check(forAll(prop[Long] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/FilterTests.scala b/dataset/src/test/scala/frameless/FilterTests.scala deleted file mode 100644 index 3f122cf4a..000000000 --- a/dataset/src/test/scala/frameless/FilterTests.scala +++ /dev/null @@ -1,164 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class FilterTests extends TypedDatasetSuite { - test("filter('a == lit(b))") { - def prop[A: TypedEncoder](elem: A, data: Vector[X1[A]])(implicit ex1: TypedEncoder[X1[A]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col('a) - - val dataset2 = dataset.filter(A === elem).collect().run().toVector - val data2 = data.filter(_.a == elem) - - dataset2 ?= data2 - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } - - test("filter('a =!= lit(b))") { - def prop[A: TypedEncoder](elem: A, data: Vector[X1[A]])(implicit ex1: TypedEncoder[X1[A]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col('a) - - val dataset2 = dataset.filter(A =!= elem).collect().run().toVector - val data2 = data.filter(_.a != elem) - - dataset2 ?= data2 - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - check(forAll(prop[Char] _)) - check(forAll(prop[Boolean] _)) - check(forAll(prop[SQLTimestamp] _)) - check(forAll(prop[Vector[SQLTimestamp]] _)) - } - - test("filter('a =!= 'b)") { - def prop[A: TypedEncoder](data: Vector[X2[A, A]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col('a) - val B = dataset.col('b) - - val dataset2 = dataset.filter(A =!= B).collect().run().toVector - val data2 = data.filter(x => x.a != x.b) - - dataset2 ?= data2 - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - check(forAll(prop[Char] _)) - check(forAll(prop[Boolean] _)) - check(forAll(prop[SQLTimestamp] _)) - check(forAll(prop[Vector[SQLTimestamp]] _)) - } - - test("filter('a =!= 'b") { - def prop[A: TypedEncoder](elem: A, data: Vector[X2[A,A]]): Prop = { - val dataset = TypedDataset.create(data) - val cA = dataset.col('a) - val cB = dataset.col('b) - - val dataset2 = dataset.filter(cA =!= cB).collect().run().toVector - val data2 = data.filter(x => x.a != x.b ) - - (dataset2 ?= data2).&&(dataset.filter(cA =!= cA).count().run() ?= 0) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - check(forAll(prop[Char] _)) - check(forAll(prop[SQLTimestamp] _)) - check(forAll(prop[Vector[SQLTimestamp]] _)) - } - - test("filter with arithmetic expressions: addition") { - check(forAll { (data: Vector[X1[Int]]) => - val ds = TypedDataset.create(data) - val res = ds.filter((ds('a) + 1) === (ds('a) + 1)).collect().run().toVector - res ?= data - }) - } - - test("filter with values (not columns): addition") { - check(forAll { (data: Vector[X1[Int]], const: Int) => - val ds = TypedDataset.create(data) - val res = ds.filter(ds('a) > const).collect().run().toVector - res ?= data.filter(_.a > const) - }) - } - - test("filter with arithmetic expressions: multiplication") { - val t = X1(1) :: X1(2) :: X1(3) :: Nil - val tds: TypedDataset[X1[Int]] = TypedDataset.create(t) - - assert(tds.filter(tds('a) * 2 === 2).collect().run().toVector === Vector(X1(1))) - assert(tds.filter(tds('a) * 3 === 3).collect().run().toVector === Vector(X1(1))) - } - - test("Option equality/inequality for columns") { - def prop[A <: Option[_] : TypedEncoder](a: A, b: A): Prop = { - val data = X2(a, b) :: X2(a, a) :: Nil - val dataset = TypedDataset.create(data) - val A = dataset.col('a) - val B = dataset.col('b) - - (data.filter(x => x.a == x.b).toSet ?= dataset.filter(A === B).collect().run().toSet). - &&(data.filter(x => x.a != x.b).toSet ?= dataset.filter(A =!= B).collect().run().toSet). - &&(data.filter(x => x.a == None).toSet ?= dataset.filter(A.isNone).collect().run().toSet). - &&(data.filter(x => x.a == None).toSet ?= dataset.filter(A.isNotNone === false).collect().run().toSet) - } - - check(forAll(prop[Option[Int]] _)) - check(forAll(prop[Option[Boolean]] _)) - check(forAll(prop[Option[SQLDate]] _)) - check(forAll(prop[Option[SQLTimestamp]] _)) - check(forAll(prop[Option[X1[String]]] _)) - check(forAll(prop[Option[X1[X1[String]]]] _)) - check(forAll(prop[Option[X1[X1[Vector[Option[Int]]]]]] _)) - } - - test("Option equality/inequality for lit") { - def prop[A <: Option[_] : TypedEncoder](a: A, b: A, cLit: A): Prop = { - val data = X2(a, b) :: X2(a, cLit) :: Nil - val dataset = TypedDataset.create(data) - val colA = dataset.col('a) - - (data.filter(x => x.a == cLit).toSet ?= dataset.filter(colA === cLit).collect().run().toSet). - &&(data.filter(x => x.a != cLit).toSet ?= dataset.filter(colA =!= cLit).collect().run().toSet). - &&(data.filter(x => x.a == None).toSet ?= dataset.filter(colA.isNone).collect().run().toSet). - &&(data.filter(x => x.a == None).toSet ?= dataset.filter(colA.isNotNone === false).collect().run().toSet) - } - - check(forAll(prop[Option[Int]] _)) - check(forAll(prop[Option[Boolean]] _)) - check(forAll(prop[Option[SQLDate]] _)) - check(forAll(prop[Option[SQLTimestamp]] _)) - check(forAll(prop[Option[String]] _)) - check(forAll(prop[Option[X1[String]]] _)) - check(forAll(prop[Option[X1[X1[String]]]] _)) - check(forAll(prop[Option[X1[X1[Vector[Option[Int]]]]]] _)) - } - - test("filter with isin values") { - def prop[A: TypedEncoder](data: Vector[X1[A]], values: Vector[A])(implicit a : CatalystIsin[A]): Prop = { - val ds = TypedDataset.create(data) - val res = ds.filter(ds('a).isin(values:_*)).collect().run().toVector - res ?= data.filter(d => values.contains(d.a)) - } - - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - check(forAll(prop[Float] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/FlattenTests.scala b/dataset/src/test/scala/frameless/FlattenTests.scala deleted file mode 100644 index a65e51b8f..000000000 --- a/dataset/src/test/scala/frameless/FlattenTests.scala +++ /dev/null @@ -1,29 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop.forAll -import org.scalacheck.Prop._ - - -class FlattenTests extends TypedDatasetSuite { - test("simple flatten test") { - val ds: TypedDataset[(Int,Option[Int])] = TypedDataset.create(Seq((1,Option(1)))) - ds.flattenOption('_2): TypedDataset[(Int,Int)] - } - - test("different Optional types") { - def prop[A: TypedEncoder](xs: List[X1[Option[A]]]): Prop = { - val tds: TypedDataset[X1[Option[A]]] = TypedDataset.create(xs) - - val framelessResults: Seq[Tuple1[A]] = tds.flattenOption('a).collect().run().toVector - val scalaResults = xs.flatMap(_.a).map(Tuple1(_)).toVector - - framelessResults ?= scalaResults - } - - check(forAll(prop[Long] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Char] _)) - check(forAll(prop[String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/GroupByTests.scala b/dataset/src/test/scala/frameless/GroupByTests.scala deleted file mode 100644 index 20250f696..000000000 --- a/dataset/src/test/scala/frameless/GroupByTests.scala +++ /dev/null @@ -1,459 +0,0 @@ -package frameless - -import frameless.functions.aggregate._ -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class GroupByTests extends TypedDatasetSuite { - test("groupByMany('a).agg(sum('b))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder, - Out: TypedEncoder : Numeric - ](data: List[X2[A, B]])( - implicit - summable: CatalystSummable[B, Out], - widen: B => Out - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - - val datasetSumByA = dataset.groupByMany(A).agg(sum(B)).collect().run.toVector.sortBy(_._1) - val sumByA = data.groupBy(_.a).mapValues(_.map(_.b).map(widen).sum).toVector.sortBy(_._1) - - datasetSumByA ?= sumByA - } - - check(forAll(prop[Int, Long, Long] _)) - } - - test("agg(sum('a))") { - def prop[A: TypedEncoder : Numeric](data: List[X1[A]])( - implicit - summable: CatalystSummable[A, A] - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val datasetSum = dataset.agg(sum(A)).collect().run().toVector - val listSum = data.map(_.a).sum - - datasetSum ?= Vector(listSum) - } - - check(forAll(prop[Long] _)) - } - - test("agg(sum('a), sum('b))") { - def prop[ - A: TypedEncoder : Numeric, - B: TypedEncoder : Numeric - ](data: List[X2[A, B]])( - implicit - as: CatalystSummable[A, A], - bs: CatalystSummable[B, B] - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - - val datasetSum = dataset.agg(sum(A), sum(B)).collect().run().toVector - val listSumA = data.map(_.a).sum - val listSumB = data.map(_.b).sum - - datasetSum ?= Vector((listSumA, listSumB)) - } - - check(forAll(prop[Long, Long] _)) - } - - test("agg(sum('a), sum('b), sum('c))") { - def prop[ - A: TypedEncoder : Numeric, - B: TypedEncoder : Numeric, - C: TypedEncoder : Numeric - ](data: List[X3[A, B, C]])( - implicit - as: CatalystSummable[A, A], - bs: CatalystSummable[B, B], - cs: CatalystSummable[C, C] - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - - val datasetSum = dataset.agg(sum(A), sum(B), sum(C)).collect().run().toVector - val listSumA = data.map(_.a).sum - val listSumB = data.map(_.b).sum - val listSumC = data.map(_.c).sum - - datasetSum ?= Vector((listSumA, listSumB, listSumC)) - } - - check(forAll(prop[Long, Long, Long] _)) - } - - test("agg(sum('a), sum('b), min('c), max('d))") { - def prop[ - A: TypedEncoder : Numeric, - B: TypedEncoder : Numeric, - C: TypedEncoder : Numeric, - D: TypedEncoder : Numeric - ](data: List[X4[A, B, C, D]])( - implicit - as: CatalystSummable[A, A], - bs: CatalystSummable[B, B], - co: CatalystOrdered[C], - fo: CatalystOrdered[D] - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - val D = dataset.col[D]('d) - - val datasetSum = dataset.agg(sum(A), sum(B), min(C), max(D)).collect().run().toVector - val listSumA = data.map(_.a).sum - val listSumB = data.map(_.b).sum - val listMinC = if(data.isEmpty) implicitly[Numeric[C]].fromInt(0) else data.map(_.c).min - val listMaxD = if(data.isEmpty) implicitly[Numeric[D]].fromInt(0) else data.map(_.d).max - - datasetSum ?= Vector(if (data.isEmpty) null else (listSumA, listSumB, listMinC, listMaxD)) - } - - check(forAll(prop[Long, Long, Long, Int] _)) - check(forAll(prop[Long, Long, Short, Short] _)) - check(forAll(prop[Long, Long, Double, BigDecimal] _)) - } - - test("groupBy('a).agg(sum('b))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder, - Out: TypedEncoder : Numeric - ](data: List[X2[A, B]])( - implicit - summable: CatalystSummable[B, Out], - widen: B => Out - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - - val datasetSumByA = dataset.groupBy(A).agg(sum(B)).collect().run.toVector.sortBy(_._1) - val sumByA = data.groupBy(_.a).mapValues(_.map(_.b).map(widen).sum).toVector.sortBy(_._1) - - datasetSumByA ?= sumByA - } - - check(forAll(prop[Int, Long, Long] _)) - } - - test("groupBy('a).mapGroups('a, sum('b))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Numeric - ](data: List[X2[A, B]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - - val datasetSumByA = dataset.groupBy(A) - .deserialized.mapGroups { case (a, xs) => (a, xs.map(_.b).sum) } - .collect().run().toVector.sortBy(_._1) - val sumByA = data.groupBy(_.a).mapValues(_.map(_.b).sum).toVector.sortBy(_._1) - - datasetSumByA ?= sumByA - } - - check(forAll(prop[Int, Long] _)) - } - - test("groupBy('a).agg(sum('b), sum('c)) to groupBy('a).agg(sum('a), sum('b), sum('a), sum('b), sum('a))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder, - C: TypedEncoder, - OutB: TypedEncoder : Numeric, - OutC: TypedEncoder : Numeric - ](data: List[X3[A, B, C]])( - implicit - summableB: CatalystSummable[B, OutB], - summableC: CatalystSummable[C, OutC], - widenb: B => OutB, - widenc: C => OutC - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - - val framelessSumBC = dataset - .groupBy(A) - .agg(sum(B), sum(C)) - .collect().run.toVector.sortBy(_._1) - - val scalaSumBC = data.groupBy(_.a).mapValues { xs => - (xs.map(_.b).map(widenb).sum, xs.map(_.c).map(widenc).sum) - }.toVector.map { - case (a, (b, c)) => (a, b, c) - }.sortBy(_._1) - - val framelessSumBCB = dataset - .groupBy(A) - .agg(sum(B), sum(C), sum(B)) - .collect().run.toVector.sortBy(_._1) - - val scalaSumBCB = data.groupBy(_.a).mapValues { xs => - (xs.map(_.b).map(widenb).sum, xs.map(_.c).map(widenc).sum, xs.map(_.b).map(widenb).sum) - }.toVector.map { - case (a, (b1, c, b2)) => (a, b1, c, b2) - }.sortBy(_._1) - - val framelessSumBCBC = dataset - .groupBy(A) - .agg(sum(B), sum(C), sum(B), sum(C)) - .collect().run.toVector.sortBy(_._1) - - val scalaSumBCBC = data.groupBy(_.a).mapValues { xs => - (xs.map(_.b).map(widenb).sum, xs.map(_.c).map(widenc).sum, xs.map(_.b).map(widenb).sum, xs.map(_.c).map(widenc).sum) - }.toVector.map { - case (a, (b1, c1, b2, c2)) => (a, b1, c1, b2, c2) - }.sortBy(_._1) - - val framelessSumBCBCB = dataset - .groupBy(A) - .agg(sum(B), sum(C), sum(B), sum(C), sum(B)) - .collect().run.toVector.sortBy(_._1) - - val scalaSumBCBCB = data.groupBy(_.a).mapValues { xs => - (xs.map(_.b).map(widenb).sum, xs.map(_.c).map(widenc).sum, xs.map(_.b).map(widenb).sum, xs.map(_.c).map(widenc).sum, xs.map(_.b).map(widenb).sum) - }.toVector.map { - case (a, (b1, c1, b2, c2, b3)) => (a, b1, c1, b2, c2, b3) - }.sortBy(_._1) - - (framelessSumBC ?= scalaSumBC) - .&&(framelessSumBCB ?= scalaSumBCB) - .&&(framelessSumBCBC ?= scalaSumBCBC) - .&&(framelessSumBCBCB ?= scalaSumBCBCB) - } - - check(forAll(prop[String, Long, BigDecimal, Long, BigDecimal] _)) - } - - test("groupBy('a, 'b).agg(sum('c)) to groupBy('a, 'b).agg(sum('c),sum('c),sum('c),sum('c),sum('c))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering, - C: TypedEncoder, - OutC: TypedEncoder: Numeric - ](data: List[X3[A, B, C]])( - implicit - summableC: CatalystSummable[C, OutC], - widenc: C => OutC - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - - val framelessSumC = dataset - .groupBy(A,B) - .agg(sum(C)) - .collect().run.toVector.sortBy(x => (x._1,x._2)) - - val scalaSumC = data.groupBy(x => (x.a,x.b)).mapValues { xs => - xs.map(_.c).map(widenc).sum - }.toVector.map { case ((a, b), c) => (a, b, c) }.sortBy(x => (x._1,x._2)) - - val framelessSumCC = dataset - .groupBy(A,B) - .agg(sum(C), sum(C)) - .collect().run.toVector.sortBy(x => (x._1,x._2)) - - val scalaSumCC = data.groupBy(x => (x.a,x.b)).mapValues { xs => - val s = xs.map(_.c).map(widenc).sum; (s,s) - }.toVector.map { case ((a, b), (c1, c2)) => (a, b, c1, c2) }.sortBy(x => (x._1,x._2)) - - val framelessSumCCC = dataset - .groupBy(A,B) - .agg(sum(C), sum(C), sum(C)) - .collect().run.toVector.sortBy(x => (x._1,x._2)) - - val scalaSumCCC = data.groupBy(x => (x.a,x.b)).mapValues { xs => - val s = xs.map(_.c).map(widenc).sum; (s,s,s) - }.toVector.map { case ((a, b), (c1, c2, c3)) => (a, b, c1, c2, c3) }.sortBy(x => (x._1,x._2)) - - val framelessSumCCCC = dataset - .groupBy(A,B) - .agg(sum(C), sum(C), sum(C), sum(C)) - .collect().run.toVector.sortBy(x => (x._1,x._2)) - - val scalaSumCCCC = data.groupBy(x => (x.a,x.b)).mapValues { xs => - val s = xs.map(_.c).map(widenc).sum; (s,s,s,s) - }.toVector.map { case ((a, b), (c1, c2, c3, c4)) => (a, b, c1, c2, c3, c4) }.sortBy(x => (x._1,x._2)) - - val framelessSumCCCCC = dataset - .groupBy(A,B) - .agg(sum(C), sum(C), sum(C), sum(C), sum(C)) - .collect().run.toVector.sortBy(x => (x._1,x._2)) - - val scalaSumCCCCC = data.groupBy(x => (x.a,x.b)).mapValues { xs => - val s = xs.map(_.c).map(widenc).sum; (s,s,s,s,s) - }.toVector.map { case ((a, b), (c1, c2, c3, c4, c5)) => (a, b, c1, c2, c3, c4, c5) }.sortBy(x => (x._1,x._2)) - - (framelessSumC ?= scalaSumC) && - (framelessSumCC ?= scalaSumCC) && - (framelessSumCCC ?= scalaSumCCC) && - (framelessSumCCCC ?= scalaSumCCCC) && - (framelessSumCCCCC ?= scalaSumCCCCC) - } - - check(forAll(prop[String, Long, BigDecimal, BigDecimal] _)) - } - - test("groupBy('a, 'b).agg(sum('c), sum('d))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering, - C: TypedEncoder, - D: TypedEncoder, - OutC: TypedEncoder : Numeric, - OutD: TypedEncoder : Numeric - ](data: List[X4[A, B, C, D]])( - implicit - summableC: CatalystSummable[C, OutC], - summableD: CatalystSummable[D, OutD], - widenc: C => OutC, - widend: D => OutD - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - val D = dataset.col[D]('d) - - val datasetSumByAB = dataset - .groupBy(A, B) - .agg(sum(C), sum(D)) - .collect().run.toVector.sortBy(x => (x._1, x._2)) - - val sumByAB = data.groupBy(x => (x.a, x.b)).mapValues { xs => - (xs.map(_.c).map(widenc).sum, xs.map(_.d).map(widend).sum) - }.toVector.map { - case ((a, b), (c, d)) => (a, b, c, d) - }.sortBy(x => (x._1, x._2)) - - datasetSumByAB ?= sumByAB - } - - check(forAll(prop[Byte, Int, Long, BigDecimal, Long, BigDecimal] _)) - } - - test("groupBy('a, 'b).mapGroups('a, 'b, sum('c))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering, - C: TypedEncoder : Numeric - ](data: List[X3[A, B, C]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - - val datasetSumByAB = dataset - .groupBy(A, B) - .deserialized.mapGroups { case ((a, b), xs) => (a, b, xs.map(_.c).sum) } - .collect().run().toVector.sortBy(x => (x._1, x._2)) - - val sumByAB = data.groupBy(x => (x.a, x.b)) - .mapValues { xs => xs.map(_.c).sum } - .toVector.map { case ((a, b), c) => (a, b, c) }.sortBy(x => (x._1, x._2)) - - datasetSumByAB ?= sumByAB - } - - check(forAll(prop[Byte, Int, Long] _)) - } - - test("groupBy('a).mapGroups(('a, toVector(('a, 'b))") { - def prop[ - A: TypedEncoder, - B: TypedEncoder - ](data: Vector[X2[A, B]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val datasetGrouped = dataset - .groupBy(A) - .deserialized.mapGroups((a, xs) => (a, xs.toVector)) - .collect().run.toMap - - val dataGrouped = data.groupBy(_.a) - - datasetGrouped ?= dataGrouped - } - - check(forAll(prop[Short, Option[Short]] _)) - check(forAll(prop[Option[Short], Short] _)) - check(forAll(prop[X1[Option[Short]], Short] _)) - } - - test("groupBy('a).flatMapGroups(('a, toVector(('a, 'b))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering - ](data: Vector[X2[A, B]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val datasetGrouped = dataset - .groupBy(A) - .deserialized.flatMapGroups((a, xs) => xs.map(x => (a, x))) - .collect().run - .sorted - - val dataGrouped = data - .groupBy(_.a).toSeq - .flatMap { case (a, xs) => xs.map(x => (a, x)) } - .sorted - - datasetGrouped ?= dataGrouped - } - - check(forAll(prop[Short, Option[Short]] _)) - check(forAll(prop[Option[Short], Short] _)) - check(forAll(prop[X1[Option[Short]], Short] _)) - } - - test("groupBy('a, 'b).flatMapGroups((('a,'b) toVector((('a,'b), 'c))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering, - C: TypedEncoder : Ordering - ](data: Vector[X3[A, B, C]]): Prop = { - val dataset = TypedDataset.create(data) - val cA = dataset.col[A]('a) - val cB = dataset.col[B]('b) - - val datasetGrouped = dataset - .groupBy(cA, cB) - .deserialized.flatMapGroups((a, xs) => xs.map(x => (a, x))) - .collect().run() - .sorted - - val dataGrouped = data - .groupBy(t => (t.a,t.b)).toSeq - .flatMap { case (a, xs) => xs.map(x => (a, x)) } - .sorted - - datasetGrouped ?= dataGrouped - } - - check(forAll(prop[Short, Option[Short], Long] _)) - check(forAll(prop[Option[Short], Short, Int] _)) - check(forAll(prop[X1[Option[Short]], Short, Byte] _)) - } -} diff --git a/dataset/src/test/scala/frameless/InjectionTests.scala b/dataset/src/test/scala/frameless/InjectionTests.scala deleted file mode 100644 index 4b3e88fd0..000000000 --- a/dataset/src/test/scala/frameless/InjectionTests.scala +++ /dev/null @@ -1,137 +0,0 @@ -package frameless - -import frameless.CollectTests.prop -import org.scalacheck._ -import org.scalacheck.Prop._ -import shapeless.test.illTyped - -sealed trait Country -case object France extends Country -case object Russia extends Country - -object Country { - implicit val arbitrary: Arbitrary[Country] = - Arbitrary(Arbitrary.arbitrary[Boolean].map(injection.invert)) - - implicit val injection: Injection[Country, Boolean] = - Injection(France.==, if (_) France else Russia) -} - -sealed trait Food -case object Burger extends Food -case object Pasta extends Food -case object Rice extends Food - -object Food { - implicit val arbitrary: Arbitrary[Food] = - Arbitrary(Arbitrary.arbitrary[Int].map(i => injection.invert(Math.abs(i % 3)))) - - implicit val injection: Injection[Food, Int] = - Injection( - { - case Burger => 0 - case Pasta => 1 - case Rice => 2 - }, - { - case 0 => Burger - case 1 => Pasta - case 2 => Rice - } - ) -} - -// Supposingly coming from a java lib, shapeless can't derive stuff for this one :( -class LocalDateTime { - var instant: Long = _ - - override def equals(o: Any): Boolean = - o.isInstanceOf[LocalDateTime] && o.asInstanceOf[LocalDateTime].instant == instant -} - -object LocalDateTime { - implicit val arbitrary: Arbitrary[LocalDateTime] = - Arbitrary(Arbitrary.arbitrary[Long].map(injection.invert)) - - implicit val injection: Injection[LocalDateTime, Long] = - Injection( - _.instant, - long => { val ldt = new LocalDateTime; ldt.instant = long; ldt } - ) -} - -case class Person(age: Int, name: String) - -object Person { - val tupled = (Person.apply _).tupled - - implicit val arbitrary: Arbitrary[Person] = - Arbitrary(Arbitrary.arbTuple2[Int, String].arbitrary.map(tupled)) - - implicit val injection: Injection[Person, (Int, String)] = - Injection(p => unapply(p).get, tupled) -} - - -case class I[A](value: A) - -object I { - implicit def injection[A]: Injection[I[A], A] = Injection(_.value, I(_)) - implicit def typedEncoder[A: TypedEncoder]: TypedEncoder[I[A]] = TypedEncoder.usingInjection[I[A], A] - implicit def arbitrary[A: Arbitrary]: Arbitrary[I[A]] = Arbitrary(Arbitrary.arbitrary[A].map(I(_))) -} - -class InjectionTests extends TypedDatasetSuite { - test("Injection based encoders") { - check(forAll(prop[Country] _)) - check(forAll(prop[LocalDateTime] _)) - check(forAll(prop[Food] _)) - check(forAll(prop[X1[Country]] _)) - check(forAll(prop[X1[LocalDateTime]] _)) - check(forAll(prop[X1[Food]] _)) - check(forAll(prop[X1[X1[Country]]] _)) - check(forAll(prop[X1[X1[LocalDateTime]]] _)) - check(forAll(prop[X1[X1[Food]]] _)) - check(forAll(prop[X2[Country, X2[LocalDateTime, Food]]] _)) - check(forAll(prop[X3[Country, LocalDateTime, Food]] _)) - check(forAll(prop[X3U[Country, LocalDateTime, Food]] _)) - - check(forAll(prop[I[Int]] _)) - check(forAll(prop[I[Option[Int]]] _)) - check(forAll(prop[I[I[Int]]] _)) - check(forAll(prop[I[I[Option[Int]]]] _)) - - check(forAll(prop[I[X1[Int]]] _)) - check(forAll(prop[I[I[X1[Int]]]] _)) - check(forAll(prop[I[I[Option[X1[Int]]]]] _)) - - check(forAll(prop[Option[I[Int]]] _)) - check(forAll(prop[Option[I[X1[Int]]]] _)) - - assert(TypedEncoder[I[Int]].catalystRepr == TypedEncoder[Int].catalystRepr) - assert(TypedEncoder[I[I[Int]]].catalystRepr == TypedEncoder[Int].catalystRepr) - - assert(TypedEncoder[I[Option[Int]]].nullable) - } - - test("TypedEncoder[Person] is ambiguous") { - illTyped("implicitly[TypedEncoder[Person]]", "ambiguous implicit values.*") - } - - test("Resolve ambiguity by importing usingInjection") { - import TypedEncoder.usingInjection - - check(forAll(prop[X1[Person]] _)) - check(forAll(prop[X1[X1[Person]]] _)) - check(forAll(prop[X2[Person, Person]] _)) - check(forAll(prop[Person] _)) - - assert(TypedEncoder[Person].catalystRepr == TypedEncoder[(Int, String)].catalystRepr) - } - - test("Resolve ambiguity by importing usingDerivation") { - import TypedEncoder.usingDerivation - assert(implicitly[TypedEncoder[Person]].isInstanceOf[RecordEncoder[Person, _, _]]) - check(forAll(prop[Person] _)) - } -} diff --git a/dataset/src/test/scala/frameless/JobTests.scala b/dataset/src/test/scala/frameless/JobTests.scala deleted file mode 100644 index 9650a020f..000000000 --- a/dataset/src/test/scala/frameless/JobTests.scala +++ /dev/null @@ -1,54 +0,0 @@ -package frameless - -import org.scalacheck.Arbitrary -import org.scalatest.BeforeAndAfterAll -import org.scalatestplus.scalacheck.ScalaCheckDrivenPropertyChecks -import org.scalatest.freespec.AnyFreeSpec -import org.scalatest.matchers.should.Matchers - - -class JobTests extends AnyFreeSpec with BeforeAndAfterAll with SparkTesting with ScalaCheckDrivenPropertyChecks with Matchers { - - "map" - { - "identity" in { - def check[T](implicit arb: Arbitrary[T]) = forAll { - t: T => Job(t).map(identity).run() shouldEqual Job(t).run() - } - - check[Int] - } - - val f1: Int => Int = _ + 1 - val f2: Int => Int = (i: Int) => i * i - - "composition" in forAll { - i: Int => Job(i).map(f1).map(f2).run() shouldEqual Job(i).map(f1 andThen f2).run() - } - } - - "flatMap" - { - val f1: Int => Job[Int] = (i: Int) => Job(i + 1) - val f2: Int => Job[Int] = (i: Int) => Job(i * i) - - "left identity" in forAll { - i: Int => Job(i).flatMap(f1).run() shouldEqual f1(i).run() - } - - "right identity" in forAll { - i: Int => Job(i).flatMap(i => Job.apply(i)).run() shouldEqual Job(i).run() - } - - "associativity" in forAll { - i: Int => Job(i).flatMap(f1).flatMap(f2).run() shouldEqual Job(i).flatMap(ii => f1(ii).flatMap(f2)).run() - } - } - - "properties" - { - "read back" in forAll { - (k:String, v: String) => - val scopedKey = "frameless.tests." + k - Job(1).withLocalProperty(scopedKey,v).run() - sc.getLocalProperty(scopedKey) shouldBe v - } - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/JoinTests.scala b/dataset/src/test/scala/frameless/JoinTests.scala deleted file mode 100644 index b34911c4f..000000000 --- a/dataset/src/test/scala/frameless/JoinTests.scala +++ /dev/null @@ -1,233 +0,0 @@ -package frameless - -import org.apache.spark.sql.types.{StructField, StructType} -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class JoinTests extends TypedDatasetSuite { - test("ab.joinCross(ac)") { - def prop[ - A : TypedEncoder : Ordering, - B : TypedEncoder : Ordering, - C : TypedEncoder : Ordering - ](left: List[X2[A, B]], right: List[X2[A, C]]): Prop = { - val leftDs = TypedDataset.create(left) - val rightDs = TypedDataset.create(right) - val joinedDs = leftDs - .joinCross(rightDs) - - val joinedData = joinedDs.collect().run().toVector.sorted - - val joined = { - for { - ab <- left - ac <- right - } yield (ab, ac) - }.toVector - - val equalSchemas = joinedDs.schema ?= StructType(Seq( - StructField("_1", leftDs.schema, nullable = false), - StructField("_2", rightDs.schema, nullable = false))) - - (joined.sorted ?= joinedData) && equalSchemas - } - - check(forAll(prop[Int, Long, String] _)) - } - - test("ab.joinFull(ac)(ab.a == ac.a)") { - def prop[ - A : TypedEncoder : Ordering, - B : TypedEncoder : Ordering, - C : TypedEncoder : Ordering - ](left: List[X2[A, B]], right: List[X2[A, C]]): Prop = { - val leftDs = TypedDataset.create(left) - val rightDs = TypedDataset.create(right) - val joinedDs = leftDs - .joinFull(rightDs)(leftDs.col('a) === rightDs.col('a)) - - val joinedData = joinedDs.collect().run().toVector.sorted - - val rightKeys = right.map(_.a).toSet - val leftKeys = left.map(_.a).toSet - val joined = { - for { - ab <- left - ac <- right if ac.a == ab.a - } yield (Some(ab), Some(ac)) - }.toVector ++ { - for { - ab <- left if !rightKeys.contains(ab.a) - } yield (Some(ab), None) - }.toVector ++ { - for { - ac <- right if !leftKeys.contains(ac.a) - } yield (None, Some(ac)) - }.toVector - - val equalSchemas = joinedDs.schema ?= StructType(Seq( - StructField("_1", leftDs.schema, nullable = true), - StructField("_2", rightDs.schema, nullable = true))) - - (joined.sorted ?= joinedData) && equalSchemas - } - - check(forAll(prop[Int, Long, String] _)) - } - - test("ab.joinInner(ac)(ab.a == ac.a)") { - def prop[ - A : TypedEncoder : Ordering, - B : TypedEncoder : Ordering, - C : TypedEncoder : Ordering - ](left: List[X2[A, B]], right: List[X2[A, C]]): Prop = { - val leftDs = TypedDataset.create(left) - val rightDs = TypedDataset.create(right) - val joinedDs = leftDs - .joinInner(rightDs)(leftDs.col('a) === rightDs.col('a)) - - val joinedData = joinedDs.collect().run().toVector.sorted - - val joined = { - for { - ab <- left - ac <- right if ac.a == ab.a - } yield (ab, ac) - }.toVector - - val equalSchemas = joinedDs.schema ?= StructType(Seq( - StructField("_1", leftDs.schema, nullable = false), - StructField("_2", rightDs.schema, nullable = false))) - - (joined.sorted ?= joinedData) && equalSchemas - } - - check(forAll(prop[Int, Long, String] _)) - } - - test("ab.joinLeft(ac)(ab.a == ac.a)") { - def prop[ - A : TypedEncoder : Ordering, - B : TypedEncoder : Ordering, - C : TypedEncoder : Ordering - ](left: List[X2[A, B]], right: List[X2[A, C]]): Prop = { - val leftDs = TypedDataset.create(left) - val rightDs = TypedDataset.create(right) - val joinedDs = leftDs - .joinLeft(rightDs)(leftDs.col('a) === rightDs.col('a)) - - val joinedData = joinedDs.collect().run().toVector.sorted - - val rightKeys = right.map(_.a).toSet - val joined = { - for { - ab <- left - ac <- right if ac.a == ab.a - } yield (ab, Some(ac)) - }.toVector ++ { - for { - ab <- left if !rightKeys.contains(ab.a) - } yield (ab, None) - }.toVector - - val equalSchemas = joinedDs.schema ?= StructType(Seq( - StructField("_1", leftDs.schema, nullable = false), - StructField("_2", rightDs.schema, nullable = true))) - - (joined.sorted ?= joinedData) && (joinedData.map(_._1).toSet ?= left.toSet) && equalSchemas - } - - check(forAll(prop[Int, Long, String] _)) - } - - test("ab.joinLeftAnti(ac)(ab.a == ac.a)") { - def prop[ - A : TypedEncoder : Ordering, - B : TypedEncoder : Ordering, - C : TypedEncoder : Ordering - ](left: List[X2[A, B]], right: List[X2[A, C]]): Prop = { - val leftDs = TypedDataset.create(left) - val rightDs = TypedDataset.create(right) - val rightKeys = right.map(_.a).toSet - val joinedDs = leftDs - .joinLeftAnti(rightDs)(leftDs.col('a) === rightDs.col('a)) - - val joinedData = joinedDs.collect().run().toVector.sorted - - val joined = { - for { - ab <- left if !rightKeys.contains(ab.a) - } yield ab - }.toVector - - val equalSchemas = joinedDs.schema ?= leftDs.schema - - (joined.sorted ?= joinedData) && equalSchemas - } - - check(forAll(prop[Int, Long, String] _)) - } - - test("ab.joinLeftSemi(ac)(ab.a == ac.a)") { - def prop[ - A : TypedEncoder : Ordering, - B : TypedEncoder : Ordering, - C : TypedEncoder : Ordering - ](left: List[X2[A, B]], right: List[X2[A, C]]): Prop = { - val leftDs = TypedDataset.create(left) - val rightDs = TypedDataset.create(right) - val rightKeys = right.map(_.a).toSet - val joinedDs = leftDs - .joinLeftSemi(rightDs)(leftDs.col('a) === rightDs.col('a)) - - val joinedData = joinedDs.collect().run().toVector.sorted - - val joined = { - for { - ab <- left if rightKeys.contains(ab.a) - } yield ab - }.toVector - - val equalSchemas = joinedDs.schema ?= leftDs.schema - - (joined.sorted ?= joinedData) && equalSchemas - } - - check(forAll(prop[Int, Long, String] _)) - } - - test("ab.joinRight(ac)(ab.a == ac.a)") { - def prop[ - A : TypedEncoder : Ordering, - B : TypedEncoder : Ordering, - C : TypedEncoder : Ordering - ](left: List[X2[A, B]], right: List[X2[A, C]]): Prop = { - val leftDs = TypedDataset.create(left) - val rightDs = TypedDataset.create(right) - val joinedDs = leftDs - .joinRight(rightDs)(leftDs.col('a) === rightDs.col('a)) - - val joinedData = joinedDs.collect().run().toVector.sorted - - val leftKeys = left.map(_.a).toSet - val joined = { - for { - ab <- left - ac <- right if ac.a == ab.a - } yield (Some(ab), ac) - }.toVector ++ { - for { - ac <- right if !leftKeys.contains(ac.a) - } yield (None, ac) - }.toVector - - val equalSchemas = joinedDs.schema ?= StructType(Seq( - StructField("_1", leftDs.schema, nullable = true), - StructField("_2", rightDs.schema, nullable = false))) - - (joined.sorted ?= joinedData) && (joinedData.map(_._2).toSet ?= right.toSet) && equalSchemas - } - - check(forAll(prop[Int, Long, String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/LitTests.scala b/dataset/src/test/scala/frameless/LitTests.scala deleted file mode 100644 index 4d9760c65..000000000 --- a/dataset/src/test/scala/frameless/LitTests.scala +++ /dev/null @@ -1,65 +0,0 @@ -package frameless - -import frameless.functions.lit - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class LitTests extends TypedDatasetSuite { - def prop[A: TypedEncoder](value: A): Prop = { - val df: TypedDataset[Int] = TypedDataset.create(1 :: Nil) - - // filter forces whole codegen - val elems = df.deserialized.filter((_:Int) => true).select(lit(value)) - .collect() - .run() - .toVector - - // otherwise it uses local relation - val localElems = df.select(lit(value)) - .collect() - .run() - .toVector - - - (localElems ?= Vector(value)) && (elems ?= Vector(value)) - } - - test("select(lit(...))") { - check(prop[Int] _) - check(prop[Long] _) - check(prop[String] _) - check(prop[SQLDate] _) - - check(prop[Option[Int]] _) - check(prop[Option[String]] _) - - check(prop[Vector[Long]] _) - check(prop[Vector[X1[Long]]] _) - - check(prop[Vector[String]] _) - check(prop[Vector[X1[String]]] _) - - check(prop[X1[Int]] _) - check(prop[X1[X1[Int]]] _) - - check(prop[Food] _) - - // doesn't work, object has to be serializable - // check(prop[frameless.LocalDateTime] _) - } - - test("#205: comparing literals encoded using Injection") { - import org.apache.spark.sql.catalyst.util.DateTimeUtils - implicit val dateAsInt: Injection[java.sql.Date, Int] = - Injection(DateTimeUtils.fromJavaDate, DateTimeUtils.toJavaDate) - - val today = new java.sql.Date(System.currentTimeMillis) - val data = Vector(P(42, today)) - val tds = TypedDataset.create(data) - - tds.filter(tds('d) === today).collect().run() - } -} - -final case class P(i: Int, d: java.sql.Date) diff --git a/dataset/src/test/scala/frameless/NumericTests.scala b/dataset/src/test/scala/frameless/NumericTests.scala deleted file mode 100644 index 0c13ae5a3..000000000 --- a/dataset/src/test/scala/frameless/NumericTests.scala +++ /dev/null @@ -1,206 +0,0 @@ -package frameless - -import org.apache.spark.sql.Encoder -import org.scalacheck.{Arbitrary, Gen, Prop} -import org.scalacheck.Prop._ -import org.scalatest.matchers.should.Matchers - -import scala.reflect.ClassTag - -class NumericTests extends TypedDatasetSuite with Matchers { - test("plus") { - def prop[A: TypedEncoder: CatalystNumeric: Numeric](a: A, b: A): Prop = { - val df = TypedDataset.create(X2(a, b) :: Nil) - val result = implicitly[Numeric[A]].plus(a, b) - val got = df.select(df.col('a) + df.col('b)).collect().run() - - got ?= (result :: Nil) - } - - check(prop[BigDecimal] _) - check(prop[Byte] _) - check(prop[Double] _) - check(prop[Int] _) - check(prop[Long] _) - check(prop[Short] _) - } - - test("minus") { - def prop[A: TypedEncoder: CatalystNumeric: Numeric](a: A, b: A): Prop = { - val df = TypedDataset.create(X2(a, b) :: Nil) - val result = implicitly[Numeric[A]].minus(a, b) - val got = df.select(df.col('a) - df.col('b)).collect().run() - - got ?= (result :: Nil) - } - - check(prop[BigDecimal] _) - check(prop[Byte] _) - check(prop[Double] _) - check(prop[Int] _) - check(prop[Long] _) - check(prop[Short] _) - } - - test("multiply") { - def prop[A: TypedEncoder : CatalystNumeric : Numeric : ClassTag](a: A, b: A): Prop = { - val df = TypedDataset.create(X2(a, b) :: Nil) - val result = implicitly[Numeric[A]].times(a, b) - val got = df.select(df.col('a) * df.col('b)).collect().run() - - got ?= (result :: Nil) - } - - check(prop[Byte] _) - check(prop[Double] _) - check(prop[Int] _) - check(prop[Long] _) - check(prop[Short] _) - } - - test("divide") { - def prop[A: TypedEncoder: CatalystNumeric: Numeric](a: A, b: A)(implicit cd: CatalystDivisible[A, Double]): Prop = { - val df = TypedDataset.create(X2(a, b) :: Nil) - if (b == 0) proved else { - val div: Double = implicitly[Numeric[A]].toDouble(a) / implicitly[Numeric[A]].toDouble(b) - val got: Seq[Double] = df.select(df.col('a) / df.col('b)).collect().run() - - got ?= (div :: Nil) - } - } - - check(prop[Byte ] _) - check(prop[Double] _) - check(prop[Int ] _) - check(prop[Long ] _) - check(prop[Short ] _) - } - - test("divide BigDecimals") { - def prop(a: BigDecimal, b: BigDecimal): Prop = { - val df = TypedDataset.create(X2(a, b) :: Nil) - if (b.doubleValue == 0) proved else { - // Spark performs something in between Double division and BigDecimal division, - // we approximate it using double vision and `approximatelyEqual`: - val div = BigDecimal(a.doubleValue / b.doubleValue) - val got = df.select(df.col('a) / df.col('b)).collect().run() - approximatelyEqual(got.head, div) - } - } - - check(prop _) - } - - test("multiply BigDecimal") { - def prop(a: BigDecimal, b: BigDecimal): Prop = { - val df = TypedDataset.create(X2(a, b) :: Nil) - val result = BigDecimal(a.doubleValue * b.doubleValue) - val got = df.select(df.col('a) * df.col('b)).collect().run() - approximatelyEqual(got.head, result) - } - - check(prop _) - } - - trait NumericMod[T] { - def mod(a: T, b: T): T - } - - object NumericMod { - implicit val byteInstance = new NumericMod[Byte] { - def mod(a: Byte, b: Byte) = (a % b).toByte - } - implicit val doubleInstance = new NumericMod[Double] { - def mod(a: Double, b: Double) = a % b - } - implicit val floatInstance = new NumericMod[Float] { - def mod(a: Float, b: Float) = a % b - } - implicit val intInstance = new NumericMod[Int] { - def mod(a: Int, b: Int) = a % b - } - implicit val longInstance = new NumericMod[Long] { - def mod(a: Long, b: Long) = a % b - } - implicit val shortInstance = new NumericMod[Short] { - def mod(a: Short, b: Short) = (a % b).toShort - } - implicit val bigDecimalInstance = new NumericMod[BigDecimal] { - def mod(a: BigDecimal, b: BigDecimal) = a % b - } - } - - test("mod") { - import NumericMod._ - - def prop[A: TypedEncoder : CatalystNumeric : NumericMod](a: A, b: A): Prop = { - val df = TypedDataset.create(X2(a, b) :: Nil) - if (b == 0) proved else { - val mod: A = implicitly[NumericMod[A]].mod(a, b) - val got: Seq[A] = df.select(df.col('a) % df.col('b)).collect().run() - - got ?= (mod :: Nil) - } - } - - check(prop[Byte] _) - check(prop[Double] _) - check(prop[Int ] _) - check(prop[Long ] _) - check(prop[Short ] _) - check(prop[BigDecimal] _) - } - - test("a mod lit(b)"){ - import NumericMod._ - - def prop[A: TypedEncoder : CatalystNumeric : NumericMod](elem: A, data: X1[A]): Prop = { - val dataset = TypedDataset.create(Seq(data)) - val a = dataset.col('a) - if (elem == 0) proved else { - val mod: A = implicitly[NumericMod[A]].mod(data.a, elem) - val got: Seq[A] = dataset.select(a % elem).collect().run() - - got ?= (mod :: Nil) - } - } - - check(prop[Byte] _) - check(prop[Double] _) - check(prop[Int ] _) - check(prop[Long ] _) - check(prop[Short ] _) - check(prop[BigDecimal] _) - } - - test("isNaN") { - val spark = session - import spark.implicits._ - - implicit val doubleWithNaN = Arbitrary { - implicitly[Arbitrary[Double]].arbitrary.flatMap(Gen.oneOf(_, Double.NaN)) - } - implicit val x1 = Arbitrary{ doubleWithNaN.arbitrary.map(X1(_)) } - - def prop[A : TypedEncoder : Encoder : CatalystNaN](data: List[X1[A]]): Prop = { - val ds = TypedDataset.create(data) - - val expected = ds.toDF().filter(!$"a".isNaN).map(_.getAs[A](0)).collect().toSeq - val rs = ds.filter(!ds('a).isNaN).collect().run().map(_.a) - - rs ?= expected - } - - check(forAll(prop[Float] _)) - check(forAll(prop[Double] _)) - } - - test("isNaN with non-nan types should not compile") { - val ds = TypedDataset.create((1, false, 'a, "b") :: Nil) - - "ds.filter(ds('_1).isNaN)" shouldNot typeCheck - "ds.filter(ds('_2).isNaN)" shouldNot typeCheck - "ds.filter(ds('_3).isNaN)" shouldNot typeCheck - "ds.filter(ds('_4).isNaN)" shouldNot typeCheck - } -} diff --git a/dataset/src/test/scala/frameless/OrderByTests.scala b/dataset/src/test/scala/frameless/OrderByTests.scala deleted file mode 100644 index 98bd7442d..000000000 --- a/dataset/src/test/scala/frameless/OrderByTests.scala +++ /dev/null @@ -1,208 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import shapeless.test.illTyped -import org.apache.spark.sql.Column -import org.scalatest.matchers.should.Matchers - -class OrderByTests extends TypedDatasetSuite with Matchers { - def sortings[A : CatalystOrdered, T]: Seq[(TypedColumn[T, A] => SortedTypedColumn[T, A], Column => Column)] = Seq( - (_.desc, _.desc), - (_.asc, _.asc), - (t => t, t => t) //default ascending - ) - - test("single column non nullable orderBy") { - def prop[A: TypedEncoder : CatalystOrdered](data: Vector[X1[A]]): Prop = { - val ds = TypedDataset.create(data) - - sortings[A, X1[A]].map { case (typ, untyp) => - ds.dataset.orderBy(untyp(ds.dataset.col("a"))).collect().toVector.?=( - ds.orderBy(typ(ds('a))).collect().run().toVector) - }.reduce(_ && _) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Boolean] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Float] _)) - check(forAll(prop[Double] _)) - check(forAll(prop[SQLDate] _)) - check(forAll(prop[SQLTimestamp] _)) - check(forAll(prop[String] _)) - } - - test("single column non nullable partition sorting") { - def prop[A: TypedEncoder : CatalystOrdered](data: Vector[X1[A]]): Prop = { - val ds = TypedDataset.create(data) - - sortings[A, X1[A]].map { case (typ, untyp) => - ds.dataset.sortWithinPartitions(untyp(ds.dataset.col("a"))).collect().toVector.?=( - ds.sortWithinPartitions(typ(ds('a))).collect().run().toVector) - }.reduce(_ && _) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Boolean] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Float] _)) - check(forAll(prop[Double] _)) - check(forAll(prop[SQLDate] _)) - check(forAll(prop[SQLTimestamp] _)) - check(forAll(prop[String] _)) - } - - test("two columns non nullable orderBy") { - def prop[A: TypedEncoder : CatalystOrdered, B: TypedEncoder : CatalystOrdered](data: Vector[X2[A,B]]): Prop = { - val ds = TypedDataset.create(data) - - sortings[A, X2[A, B]].reverse.zip(sortings[B, X2[A, B]]).map { case ((typA, untypA), (typB, untypB)) => - val vanillaSpark = ds.dataset.orderBy(untypA(ds.dataset.col("a")), untypB(ds.dataset.col("b"))).collect().toVector - vanillaSpark.?=(ds.orderBy(typA(ds('a)), typB(ds('b))).collect().run().toVector).&&( - vanillaSpark ?= ds.orderByMany(typA(ds('a)), typB(ds('b))).collect().run().toVector - ) - }.reduce(_ && _) - } - - check(forAll(prop[SQLDate, Long] _)) - check(forAll(prop[String, Boolean] _)) - check(forAll(prop[SQLTimestamp, Long] _)) - } - - test("two columns non nullable partition sorting") { - def prop[A: TypedEncoder : CatalystOrdered, B: TypedEncoder : CatalystOrdered](data: Vector[X2[A,B]]): Prop = { - val ds = TypedDataset.create(data) - - sortings[A, X2[A, B]].reverse.zip(sortings[B, X2[A, B]]).map { case ((typA, untypA), (typB, untypB)) => - val vanillaSpark = ds.dataset.sortWithinPartitions(untypA(ds.dataset.col("a")), untypB(ds.dataset.col("b"))).collect().toVector - vanillaSpark.?=(ds.sortWithinPartitions(typA(ds('a)), typB(ds('b))).collect().run().toVector).&&( - vanillaSpark ?= ds.sortWithinPartitionsMany(typA(ds('a)), typB(ds('b))).collect().run().toVector - ) - }.reduce(_ && _) - } - - check(forAll(prop[SQLDate, Long] _)) - check(forAll(prop[String, Boolean] _)) - check(forAll(prop[SQLTimestamp, Long] _)) - } - - test("three columns non nullable orderBy") { - def prop[A: TypedEncoder : CatalystOrdered, B: TypedEncoder : CatalystOrdered](data: Vector[X3[A,B,A]]): Prop = { - val ds = TypedDataset.create(data) - - sortings[A, X3[A, B, A]].reverse - .zip(sortings[B, X3[A, B, A]]) - .zip(sortings[A, X3[A, B, A]]) - .map { case (((typA, untypA), (typB, untypB)), (typA2, untypA2)) => - val vanillaSpark = ds.dataset - .orderBy(untypA(ds.dataset.col("a")), untypB(ds.dataset.col("b")), untypA2(ds.dataset.col("c"))) - .collect().toVector - - vanillaSpark.?=(ds.orderBy(typA(ds('a)), typB(ds('b)), typA2(ds('c))).collect().run().toVector).&&( - vanillaSpark ?= ds.orderByMany(typA(ds('a)), typB(ds('b)), typA2(ds('c))).collect().run().toVector - ) - }.reduce(_ && _) - } - - check(forAll(prop[SQLDate, Long] _)) - check(forAll(prop[String, Boolean] _)) - check(forAll(prop[SQLTimestamp, Long] _)) - } - - test("three columns non nullable partition sorting") { - def prop[A: TypedEncoder : CatalystOrdered, B: TypedEncoder : CatalystOrdered](data: Vector[X3[A,B,A]]): Prop = { - val ds = TypedDataset.create(data) - - sortings[A, X3[A, B, A]].reverse - .zip(sortings[B, X3[A, B, A]]) - .zip(sortings[A, X3[A, B, A]]) - .map { case (((typA, untypA), (typB, untypB)), (typA2, untypA2)) => - val vanillaSpark = ds.dataset - .sortWithinPartitions(untypA(ds.dataset.col("a")), untypB(ds.dataset.col("b")), untypA2(ds.dataset.col("c"))) - .collect().toVector - - vanillaSpark.?=(ds.sortWithinPartitions(typA(ds('a)), typB(ds('b)), typA2(ds('c))).collect().run().toVector).&&( - vanillaSpark ?= ds.sortWithinPartitionsMany(typA(ds('a)), typB(ds('b)), typA2(ds('c))).collect().run().toVector - ) - }.reduce(_ && _) - } - - check(forAll(prop[SQLDate, Long] _)) - check(forAll(prop[String, Boolean] _)) - check(forAll(prop[SQLTimestamp, Long] _)) - } - - test("sort support for mixed default and explicit ordering") { - def prop[A: TypedEncoder : CatalystOrdered, B: TypedEncoder : CatalystOrdered](data: Vector[X2[A, B]]): Prop = { - val ds = TypedDataset.create(data) - - ds.dataset.orderBy(ds.dataset.col("a"), ds.dataset.col("b").desc).collect().toVector.?=( - ds.orderByMany(ds('a), ds('b).desc).collect().run().toVector) && - ds.dataset.sortWithinPartitions(ds.dataset.col("a"), ds.dataset.col("b").desc).collect().toVector.?=( - ds.sortWithinPartitionsMany(ds('a), ds('b).desc).collect().run().toVector) - } - - check(forAll(prop[SQLDate, Long] _)) - check(forAll(prop[String, Boolean] _)) - check(forAll(prop[SQLTimestamp, Long] _)) - } - - test("fail when selected column is not sortable") { - val d = TypedDataset.create(X2(1, Map(1 -> 2)) :: X2(2, Map(2 -> 2)) :: Nil) - d.orderBy(d('a).desc) - illTyped("""d.orderBy(d('b).desc)""") - illTyped("""d.sortWithinPartitions(d('b).desc)""") - } - - test("derives a CatalystOrdered for case classes when all fields are comparable") { - type T[A, B] = X3[Int, Boolean, X2[A, B]] - def prop[ - A: TypedEncoder : CatalystOrdered, - B: TypedEncoder : CatalystOrdered - ](data: Vector[T[A, B]]): Prop = { - val ds = TypedDataset.create(data) - - sortings[X2[A, B], T[A, B]].map { case (typX2, untypX2) => - val vanilla = ds.dataset.orderBy(untypX2(ds.dataset.col("c"))).collect().toVector - val frameless = ds.orderBy(typX2(ds('c))).collect().run.toVector - vanilla ?= frameless - }.reduce(_ && _) - } - - check(forAll(prop[Int, Long] _)) - check(forAll(prop[(String, SQLDate), Float] _)) - // Check that nested case classes are properly derived too - check(forAll(prop[X2[Boolean, Float], X4[SQLTimestamp, Double, Short, Byte]] _)) - } - - test("derives a CatalystOrdered for tuples when all fields are comparable") { - type T[A, B] = X2[Int, (A, B)] - def prop[ - A: TypedEncoder : CatalystOrdered, - B: TypedEncoder : CatalystOrdered - ](data: Vector[T[A, B]]): Prop = { - val ds = TypedDataset.create(data) - - sortings[(A, B), T[A, B]].map { case (typX2, untypX2) => - val vanilla = ds.dataset.orderBy(untypX2(ds.dataset.col("b"))).collect().toVector - val frameless = ds.orderBy(typX2(ds('b))).collect().run.toVector - vanilla ?= frameless - }.reduce(_ && _) - } - - check(forAll(prop[Int, Long] _)) - check(forAll(prop[(String, SQLDate), Float] _)) - check(forAll(prop[X2[Boolean, Float], X1[(SQLTimestamp, Double, Short, Byte)]] _)) - } - - test("fails to compile when one of the field isn't comparable") { - type T = X2[Int, X2[Int, Map[String, String]]] - val d = TypedDataset.create(X2(1, X2(2, Map("not" -> "comparable"))) :: Nil) - illTyped("d.orderBy(d('b).desc)", """Cannot compare columns of type frameless.X2\[Int,scala.collection.immutable.Map\[String,String]].""") - } -} diff --git a/dataset/src/test/scala/frameless/RecordEncoderTests.scala b/dataset/src/test/scala/frameless/RecordEncoderTests.scala deleted file mode 100644 index 44b404181..000000000 --- a/dataset/src/test/scala/frameless/RecordEncoderTests.scala +++ /dev/null @@ -1,79 +0,0 @@ -package frameless - -import org.apache.spark.sql.Row -import org.apache.spark.sql.types.StructType -import shapeless.{HList, LabelledGeneric} -import shapeless.test.illTyped -import org.scalatest.matchers.should.Matchers - -case class UnitsOnly(a: Unit, b: Unit) - -case class TupleWithUnits(u0: Unit, _1: Int, u1: Unit, u2: Unit, _2: String, u3: Unit) - -object TupleWithUnits { - def apply(_1: Int, _2: String): TupleWithUnits = TupleWithUnits((), _1, (), (), _2, ()) -} - -case class OptionalNesting(o: Option[TupleWithUnits]) - -object RecordEncoderTests { - case class A(x: Int) - case class B(a: Seq[A]) - case class C(b: B) -} - -class RecordEncoderTests extends TypedDatasetSuite with Matchers { - test("Unable to encode products made from units only") { - illTyped("""TypedEncoder[UnitsOnly]""") - } - - test("Dropping fields") { - def dropUnitValues[L <: HList](l: L)(implicit d: DropUnitValues[L]): d.Out = d(l) - val fields = LabelledGeneric[TupleWithUnits].to(TupleWithUnits(42, "something")) - dropUnitValues(fields) shouldEqual LabelledGeneric[(Int, String)].to((42, "something")) - } - - test("Representation skips units") { - assert(TypedEncoder[(Int, String)].catalystRepr == TypedEncoder[TupleWithUnits].catalystRepr) - } - - test("Serialization skips units") { - val df = session.createDataFrame(Seq((1, "one"), (2, "two"))) - val ds = df.as[TupleWithUnits](TypedExpressionEncoder[TupleWithUnits]) - val tds = TypedDataset.create(Seq(TupleWithUnits(1, "one"), TupleWithUnits(2, "two"))) - - df.collect shouldEqual tds.toDF.collect - ds.collect.toSeq shouldEqual tds.collect.run - } - - test("Empty nested record value becomes null on serialization") { - val ds = TypedDataset.create(Seq(OptionalNesting(Option.empty))) - val df = ds.toDF - df.na.drop.count shouldBe 0 - } - - test("Empty nested record value becomes none on deserialization") { - val rdd = sc.parallelize(Seq(Row(null))) - val schema = TypedEncoder[OptionalNesting].catalystRepr.asInstanceOf[StructType] - val df = session.createDataFrame(rdd, schema) - val ds = TypedDataset.createUnsafe(df)(TypedEncoder[OptionalNesting]) - ds.firstOption.run.get.o.isEmpty shouldBe true - } - - test("Deeply nested optional values have correct deserialization") { - val rdd = sc.parallelize(Seq(Row(true, Row(null, null)))) - type NestedOptionPair = X2[Boolean, Option[X2[Option[Int], Option[String]]]] - val schema = TypedEncoder[NestedOptionPair].catalystRepr.asInstanceOf[StructType] - val df = session.createDataFrame(rdd, schema) - val ds = TypedDataset.createUnsafe(df)(TypedEncoder[NestedOptionPair]) - ds.firstOption.run.get shouldBe X2(true, Some(X2(None, None))) - } - - test("Nesting with collection") { - import RecordEncoderTests._ - val obj = C(B(Seq(A(1)))) - val rdd = sc.parallelize(Seq(obj)) - val ds = session.createDataset(rdd)(TypedExpressionEncoder[C]) - ds.collect.head shouldBe obj - } -} diff --git a/dataset/src/test/scala/frameless/SchemaTests.scala b/dataset/src/test/scala/frameless/SchemaTests.scala deleted file mode 100644 index 92fd33057..000000000 --- a/dataset/src/test/scala/frameless/SchemaTests.scala +++ /dev/null @@ -1,54 +0,0 @@ -package frameless - -import frameless.functions.aggregate._ -import frameless.functions._ -import org.apache.spark.sql.types.StructType -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import org.scalatest.matchers.should.Matchers - -class SchemaTests extends TypedDatasetSuite with Matchers { - - def structToNonNullable(struct: StructType): StructType = { - StructType(struct.fields.map( f => f.copy(nullable = false))) - } - - def prop[A](dataset: TypedDataset[A], ignoreNullable: Boolean = false): Prop = { - val schema = dataset.dataset.schema - - Prop.all( - if (!ignoreNullable) - dataset.schema ?= schema - else - structToNonNullable(dataset.schema) ?= structToNonNullable(schema), - if (!ignoreNullable) - TypedExpressionEncoder.targetStructType(dataset.encoder) ?= schema - else - structToNonNullable(TypedExpressionEncoder.targetStructType(dataset.encoder)) ?= structToNonNullable(schema) - ) - } - - test("schema of groupBy('a).agg(sum('b))") { - val df0 = TypedDataset.create(X2(1L, 1L) :: Nil) - val _a = df0.col('a) - val _b = df0.col('b) - - val df = df0.groupBy(_a).agg(sum(_b)) - - check(prop(df, true)) - } - - test("schema of select(lit(1L))") { - val df0 = TypedDataset.create("test" :: Nil) - val df = df0.select(lit(1L)) - - check(prop(df)) - } - - test("schema of select(lit(1L), lit(2L)).as[X2[Long, Long]]") { - val df0 = TypedDataset.create("test" :: Nil) - val df = df0.select(lit(1L), lit(2L)).as[X2[Long, Long]] - - check(prop(df)) - } -} diff --git a/dataset/src/test/scala/frameless/SelectTests.scala b/dataset/src/test/scala/frameless/SelectTests.scala deleted file mode 100644 index 8043fc941..000000000 --- a/dataset/src/test/scala/frameless/SelectTests.scala +++ /dev/null @@ -1,399 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import shapeless.test.illTyped -import scala.reflect.ClassTag - -class SelectTests extends TypedDatasetSuite { - test("select('a) FROM abcd") { - def prop[A, B, C, D](data: Vector[X4[A, B, C, D]])( - implicit - ea: TypedEncoder[A], - ex4: TypedEncoder[X4[A, B, C, D]], - ca: ClassTag[A] - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val dataset2 = dataset.select(A).collect().run().toVector - val data2 = data.map { case X4(a, _, _, _) => a } - - dataset2 ?= data2 - } - - check(forAll(prop[Int, Int, Int, Int] _)) - check(forAll(prop[X2[Int, Int], Int, Int, Int] _)) - check(forAll(prop[String, Int, Int, Int] _)) - check(forAll(prop[UdtEncodedClass, Int, Int, Int] _)) - } - - test("select('a, 'b) FROM abcd") { - def prop[A, B, C, D](data: Vector[X4[A, B, C, D]])( - implicit - ea: TypedEncoder[A], - eb: TypedEncoder[B], - eab: TypedEncoder[(A, B)], - ex4: TypedEncoder[X4[A, B, C, D]], - ca: ClassTag[A] - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - - val dataset2 = dataset.select(A, B).collect().run().toVector - val data2 = data.map { case X4(a, b, _, _) => (a, b) } - - dataset2 ?= data2 - } - - check(forAll(prop[Int, Int, Int, Int] _)) - check(forAll(prop[String, Int, Int, Int] _)) - check(forAll(prop[String, String, Int, Int] _)) - } - - test("select('a, 'b, 'c) FROM abcd") { - def prop[A, B, C, D](data: Vector[X4[A, B, C, D]])( - implicit - ea: TypedEncoder[A], - eb: TypedEncoder[B], - ec: TypedEncoder[C], - eab: TypedEncoder[(A, B, C)], - ex4: TypedEncoder[X4[A, B, C, D]], - ca: ClassTag[A] - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - - val dataset2 = dataset.select(A, B, C).collect().run().toVector - val data2 = data.map { case X4(a, b, c, _) => (a, b, c) } - - dataset2 ?= data2 - } - - check(forAll(prop[Int, Int, Int, Int] _)) - check(forAll(prop[String, Int, Int, Int] _)) - check(forAll(prop[String, String, Int, Int] _)) - } - - test("select('a,'b,'c,'d) FROM abcd") { - def prop[A, B, C, D](data: Vector[X4[A, B, C, D]])( - implicit - ea: TypedEncoder[A], - eb: TypedEncoder[B], - ec: TypedEncoder[C], - ed: TypedEncoder[D], - ex4: TypedEncoder[X4[A, B, C, D]], - ca: ClassTag[A] - ): Prop = { - val dataset = TypedDataset.create(data) - val a1 = dataset.col[A]('a) - val a2 = dataset.col[B]('b) - val a3 = dataset.col[C]('c) - val a4 = dataset.col[D]('d) - - val dataset2 = dataset.select(a1, a2, a3, a4).collect().run().toVector - val data2 = data.map { case X4(a, b, c, d) => (a, b, c, d) } - - dataset2 ?= data2 - } - - check(forAll(prop[Int, Int, Int, Int] _)) - check(forAll(prop[String, Int, Int, Int] _)) - check(forAll(prop[String, Boolean, Int, Float] _)) - } - - test("select('a,'b,'c,'d,'a) FROM abcd") { - def prop[A, B, C, D](data: Vector[X4[A, B, C, D]])( - implicit - ea: TypedEncoder[A], - eb: TypedEncoder[B], - ec: TypedEncoder[C], - ed: TypedEncoder[D], - ex4: TypedEncoder[X4[A, B, C, D]], - ca: ClassTag[A] - ): Prop = { - val dataset = TypedDataset.create(data) - val a1 = dataset.col[A]('a) - val a2 = dataset.col[B]('b) - val a3 = dataset.col[C]('c) - val a4 = dataset.col[D]('d) - - val dataset2 = dataset.select(a1, a2, a3, a4, a1).collect().run().toVector - val data2 = data.map { case X4(a, b, c, d) => (a, b, c, d, a) } - - dataset2 ?= data2 - } - - check(forAll(prop[Int, Int, Int, Int] _)) - check(forAll(prop[String, Int, Int, Int] _)) - check(forAll(prop[String, Boolean, Int, Float] _)) - } - - test("select('a,'b,'c,'d,'a, 'c) FROM abcd") { - def prop[A, B, C, D](data: Vector[X4[A, B, C, D]])( - implicit - ea: TypedEncoder[A], - eb: TypedEncoder[B], - ec: TypedEncoder[C], - ed: TypedEncoder[D], - ex4: TypedEncoder[X4[A, B, C, D]], - ca: ClassTag[A] - ): Prop = { - val dataset = TypedDataset.create(data) - val a1 = dataset.col[A]('a) - val a2 = dataset.col[B]('b) - val a3 = dataset.col[C]('c) - val a4 = dataset.col[D]('d) - - val dataset2 = dataset.select(a1, a2, a3, a4, a1, a3).collect().run().toVector - val data2 = data.map { case X4(a, b, c, d) => (a, b, c, d, a, c) } - - dataset2 ?= data2 - } - - check(forAll(prop[Int, Int, Int, Int] _)) - check(forAll(prop[String, Int, Int, Int] _)) - check(forAll(prop[String, Boolean, Int, Float] _)) - } - - test("select('a,'b,'c,'d,'a,'c,'b) FROM abcd") { - def prop[A, B, C, D](data: Vector[X4[A, B, C, D]])( - implicit - ea: TypedEncoder[A], - eb: TypedEncoder[B], - ec: TypedEncoder[C], - ed: TypedEncoder[D], - ex4: TypedEncoder[X4[A, B, C, D]], - ca: ClassTag[A] - ): Prop = { - val dataset = TypedDataset.create(data) - val a1 = dataset.col[A]('a) - val a2 = dataset.col[B]('b) - val a3 = dataset.col[C]('c) - val a4 = dataset.col[D]('d) - - val dataset2 = dataset.select(a1, a2, a3, a4, a1, a3, a2).collect().run().toVector - val data2 = data.map { case X4(a, b, c, d) => (a, b, c, d, a, c, b) } - - dataset2 ?= data2 - } - - check(forAll(prop[Int, Int, Int, Int] _)) - check(forAll(prop[String, Int, Int, Int] _)) - check(forAll(prop[String, Boolean, Int, Float] _)) - } - - test("select('a,'b,'c,'d,'a,'c,'b, 'a) FROM abcd") { - def prop[A, B, C, D](data: Vector[X4[A, B, C, D]])( - implicit - ea: TypedEncoder[A], - eb: TypedEncoder[B], - ec: TypedEncoder[C], - ed: TypedEncoder[D], - ex4: TypedEncoder[X4[A, B, C, D]], - ca: ClassTag[A] - ): Prop = { - val dataset = TypedDataset.create(data) - val a1 = dataset.col[A]('a) - val a2 = dataset.col[B]('b) - val a3 = dataset.col[C]('c) - val a4 = dataset.col[D]('d) - - val dataset2 = dataset.select(a1, a2, a3, a4, a1, a3, a2, a1).collect().run().toVector - val data2 = data.map { case X4(a, b, c, d) => (a, b, c, d, a, c, b, a) } - - dataset2 ?= data2 - } - - check(forAll(prop[Int, Int, Int, Int] _)) - check(forAll(prop[String, Int, Int, Int] _)) - check(forAll(prop[String, Boolean, Int, Float] _)) - } - - test("select('a,'b,'c,'d,'a,'c,'b,'a,'c) FROM abcd") { - def prop[A, B, C, D](data: Vector[X4[A, B, C, D]])( - implicit - ea: TypedEncoder[A], - eb: TypedEncoder[B], - ec: TypedEncoder[C], - ed: TypedEncoder[D], - ex4: TypedEncoder[X4[A, B, C, D]], - ca: ClassTag[A] - ): Prop = { - val dataset = TypedDataset.create(data) - val a1 = dataset.col[A]('a) - val a2 = dataset.col[B]('b) - val a3 = dataset.col[C]('c) - val a4 = dataset.col[D]('d) - - val dataset2 = dataset.select(a1, a2, a3, a4, a1, a3, a2, a1, a3).collect().run().toVector - val data2 = data.map { case X4(a, b, c, d) => (a, b, c, d, a, c, b, a, c) } - - dataset2 ?= data2 - } - - check(forAll(prop[Int, Int, Int, Int] _)) - check(forAll(prop[String, Int, Int, Int] _)) - check(forAll(prop[String, Boolean, Int, Float] _)) - } - - test("select('a,'b,'c,'d,'a,'c,'b,'a,'c, 'd) FROM abcd") { - def prop[A, B, C, D](data: Vector[X4[A, B, C, D]])( - implicit - ea: TypedEncoder[A], - eb: TypedEncoder[B], - ec: TypedEncoder[C], - ed: TypedEncoder[D], - ex4: TypedEncoder[X4[A, B, C, D]], - ca: ClassTag[A] - ): Prop = { - val dataset = TypedDataset.create(data) - val a1 = dataset.col[A]('a) - val a2 = dataset.col[B]('b) - val a3 = dataset.col[C]('c) - val a4 = dataset.col[D]('d) - - val dataset2 = dataset.select(a1, a2, a3, a4, a1, a3, a2, a1, a3, a4).collect().run().toVector - val data2 = data.map { case X4(a, b, c, d) => (a, b, c, d, a, c, b, a, c, d) } - - dataset2 ?= data2 - } - - check(forAll(prop[Int, Int, Int, Int] _)) - check(forAll(prop[String, Int, Int, Int] _)) - check(forAll(prop[String, Boolean, Int, Float] _)) - } - - test("select('a.b)") { - def prop[A, B, C](data: Vector[X2[X2[A, B], C]])( - implicit - eabc: TypedEncoder[X2[X2[A, B], C]], - eb: TypedEncoder[B], - cb: ClassTag[B] - ): Prop = { - val dataset = TypedDataset.create(data) - val AB = dataset.colMany('a, 'b) - - val dataset2 = dataset.select(AB).collect().run().toVector - val data2 = data.map { case X2(X2(_, b), _) => b } - - dataset2 ?= data2 - } - - check(forAll(prop[Int, String, Double] _)) - } - - test("select with column expression addition") { - def prop[A](data: Vector[X1[A]], const: A)( - implicit - eabc: TypedEncoder[X1[A]], - anum: CatalystNumeric[A], - num: Numeric[A], - eb: TypedEncoder[A] - ): Prop = { - val ds = TypedDataset.create(data) - - val dataset2 = ds.select(ds('a) + const).collect().run().toVector - val data2 = data.map { case X1(a) => num.plus(a, const) } - - dataset2 ?= data2 - } - - check(forAll(prop[Short] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Double] _)) - } - - test("select with column expression multiplication") { - def prop[A](data: Vector[X1[A]], const: A)( - implicit - eabc: TypedEncoder[X1[A]], - anum: CatalystNumeric[A], - num: Numeric[A], - eb: TypedEncoder[A] - ): Prop = { - val ds = TypedDataset.create(data) - - val dataset2 = ds.select(ds('a) * const).collect().run().toVector - val data2 = data.map { case X1(a) => num.times(a, const) } - - dataset2 ?= data2 - } - - check(forAll(prop[Short] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Double] _)) - } - - test("select with column expression subtraction") { - def prop[A](data: Vector[X1[A]], const: A)( - implicit - eabc: TypedEncoder[X1[A]], - cnum: CatalystNumeric[A], - num: Numeric[A], - eb: TypedEncoder[A] - ): Prop = { - val ds = TypedDataset.create(data) - - val dataset2 = ds.select(ds('a) - const).collect().run().toVector - val data2 = data.map { case X1(a) => num.minus(a, const) } - - dataset2 ?= data2 - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Double] _)) - } - - test("select with column expression division") { - def prop[A](data: Vector[X1[A]], const: A)( - implicit - eabc: TypedEncoder[X1[A]], - anum: CatalystNumeric[A], - frac: Fractional[A], - eb: TypedEncoder[A] - ): Prop = { - val ds = TypedDataset.create(data) - - if (const != 0) { - val dataset2 = ds.select(ds('a) / const).collect().run().toVector.asInstanceOf[Vector[A]] - val data2 = data.map { case X1(a) => frac.div(a, const) } - dataset2 ?= data2 - } else 0 ?= 0 - } - - check(forAll(prop[Double] _)) - } - - test("tests to cover problematic dataframe column names during projections") { - case class Foo(i: Int) - val e = TypedDataset.create[Foo](Foo(1) :: Nil) - val t: TypedDataset[(Int, Int)] = e.select(e.col('i) * 2, e.col('i)) - assert(t.select(t.col('_1)).collect().run().toList === List(2)) - // Issue #54 - val fooT = t.select(t.col('_1)).deserialized.map(x => Tuple1.apply(x)).as[Foo] - assert(fooT.select(fooT('i)).collect().run().toList === List(2)) - } - - test("unary - on arithmetic") { - val e = TypedDataset.create[(Int, String, Int)]((1, "a", 2) :: (2, "b", 4) :: (2, "b", 1) :: Nil) - assert(e.select(-e('_1)).collect().run().toVector === Vector(-1, -2, -2)) - assert(e.select(-(e('_1) + e('_3))).collect().run().toVector === Vector(-3, -6, -3)) - } - - test("unary - on strings should not type check") { - val e = TypedDataset.create[(Int, String, Long)]((1, "a", 2L) :: (2, "b", 4L) :: (2, "b", 1L) :: Nil) - illTyped("""e.select( -e('_2) )""") - } - - test("select with aggregation operations is not supported") { - val e = TypedDataset.create[(Int, String, Long)]((1, "a", 2L) :: (2, "b", 4L) :: (2, "b", 1L) :: Nil) - illTyped("""e.select(frameless.functions.aggregate.sum(e('_1)))""") - } -} diff --git a/dataset/src/test/scala/frameless/SelfJoinTests.scala b/dataset/src/test/scala/frameless/SelfJoinTests.scala deleted file mode 100644 index 54268eccf..000000000 --- a/dataset/src/test/scala/frameless/SelfJoinTests.scala +++ /dev/null @@ -1,146 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import org.apache.spark.sql.{SparkSession, functions => sparkFunctions} - -class SelfJoinTests extends TypedDatasetSuite { - // Without crossJoin.enabled=true Spark doesn't like trivial join conditions: - // [error] Join condition is missing or trivial. - // [error] Use the CROSS JOIN syntax to allow cartesian products between these relations. - def allowTrivialJoin[T](body: => T)(implicit session: SparkSession): T = { - val crossJoin = "spark.sql.crossJoin.enabled" - val oldSetting = session.conf.get(crossJoin) - session.conf.set(crossJoin, "true") - val result = body - session.conf.set(crossJoin, oldSetting) - result - } - - def allowAmbiguousJoin[T](body: => T)(implicit session: SparkSession): T = { - val crossJoin = "spark.sql.analyzer.failAmbiguousSelfJoin" - val oldSetting = session.conf.get(crossJoin) - session.conf.set(crossJoin, "false") - val result = body - session.conf.set(crossJoin, oldSetting) - result - } - - test("self join with colLeft/colRight disambiguation") { - def prop[ - A : TypedEncoder : Ordering, - B : TypedEncoder : Ordering - ](dx: List[X2[A, B]], d: X2[A, B]): Prop = allowAmbiguousJoin { - val data = d :: dx - val ds = TypedDataset.create(data) - - // This is the way to write unambiguous self-join in vanilla, see https://goo.gl/XnkSUD - val df1 = ds.dataset.as("df1") - val df2 = ds.dataset.as("df2") - val vanilla = df1.join(df2, - sparkFunctions.col("df1.a") === sparkFunctions.col("df2.a")).count() - - val typed = ds.joinInner(ds)( - ds.colLeft('a) === ds.colRight('a) - ).count().run() - - vanilla ?= typed - } - - check(prop[Int, Int] _) - } - - test("trivial self join") { - def prop[ - A : TypedEncoder : Ordering, - B : TypedEncoder : Ordering - ](dx: List[X2[A, B]], d: X2[A, B]): Prop = - allowTrivialJoin { allowAmbiguousJoin { - - val data = d :: dx - val ds = TypedDataset.create(data) - val untyped = ds.dataset - // Interestingly, even with aliasing it seems that it's impossible to - // obtain a trivial join condition of shape df1.a == df1.a, Spark we - // always interpret that as df1.a == df2.a. For the purpose of this - // test we fall-back to lit(true) instead. - // val trivial = sparkFunctions.col("df1.a") === sparkFunctions.col("df1.a") - val trivial = sparkFunctions.lit(true) - val vanilla = untyped.as("df1").join(untyped.as("df2"), trivial).count() - - val typed = ds.joinInner(ds)(ds.colLeft('a) === ds.colLeft('a)).count().run - vanilla ?= typed - } } - - check(prop[Int, Int] _) - } - - test("self join with unambiguous expression") { - def prop[ - A : TypedEncoder : CatalystNumeric : Ordering, - B : TypedEncoder : Ordering - ](data: List[X3[A, A, B]]): Prop = allowAmbiguousJoin { - val ds = TypedDataset.create(data) - - val df1 = ds.dataset.alias("df1") - val df2 = ds.dataset.alias("df2") - - val vanilla = df1.join(df2, - (sparkFunctions.col("df1.a") + sparkFunctions.col("df1.b")) === - (sparkFunctions.col("df2.a") + sparkFunctions.col("df2.b"))).count() - - val typed = ds.joinInner(ds)( - (ds.colLeft('a) + ds.colLeft('b)) === (ds.colRight('a) + ds.colRight('b)) - ).count().run() - - vanilla ?= typed - } - - check(prop[Int, Int] _) - } - - test("Do you want ambiguous self join? This is how you get ambiguous self join.") { - def prop[ - A : TypedEncoder : CatalystNumeric : Ordering, - B : TypedEncoder : Ordering - ](data: List[X3[A, A, B]]): Prop = - allowTrivialJoin { allowAmbiguousJoin { - val ds = TypedDataset.create(data) - - // The point I'm making here is that it "behaves just like Spark". I - // don't know (or really care about how) how Spark disambiguates that - // internally... - val vanilla = ds.dataset.join(ds.dataset, - (ds.dataset("a") + ds.dataset("b")) === - (ds.dataset("a") + ds.dataset("b"))).count() - - val typed = ds.joinInner(ds)( - (ds.col('a) + ds.col('b)) === (ds.col('a) + ds.col('b)) - ).count().run() - - vanilla ?= typed - } } - - check(prop[Int, Int] _) - } - - test("colLeft and colRight are equivalant to col outside of joins") { - def prop[A, B, C, D](data: Vector[X4[A, B, C, D]])( - implicit - ea: TypedEncoder[A], - ex4: TypedEncoder[X4[A, B, C, D]] - ): Prop = { - val dataset = TypedDataset.create(data) - val selectedCol = dataset.select(dataset.col [A]('a)).collect().run().toVector - val selectedColLeft = dataset.select(dataset.colLeft [A]('a)).collect().run().toVector - val selectedColRight = dataset.select(dataset.colRight[A]('a)).collect().run().toVector - - (selectedCol ?= selectedColLeft) && (selectedCol ?= selectedColRight) - } - - check(forAll(prop[Int, Int, Int, Int] _)) - check(forAll(prop[X2[Int, Int], Int, Int, Int] _)) - check(forAll(prop[String, Int, Int, Int] _)) - check(forAll(prop[UdtEncodedClass, Int, Int, Int] _)) - } -} diff --git a/dataset/src/test/scala/frameless/TypedDatasetSuite.scala b/dataset/src/test/scala/frameless/TypedDatasetSuite.scala deleted file mode 100644 index 36739c672..000000000 --- a/dataset/src/test/scala/frameless/TypedDatasetSuite.scala +++ /dev/null @@ -1,71 +0,0 @@ -package frameless - -import org.apache.spark.{SparkConf, SparkContext} -import org.apache.spark.sql.{SQLContext, SparkSession} -import org.scalactic.anyvals.PosZInt -import org.scalatest.BeforeAndAfterAll -import org.scalatestplus.scalacheck.Checkers -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import scala.util.{Properties, Try} -import org.scalatest.funsuite.AnyFunSuite - -trait SparkTesting { self: BeforeAndAfterAll => - - val appID: String = new java.util.Date().toString + math.floor(math.random * 10E4).toLong.toString - - val conf: SparkConf = new SparkConf() - .setMaster("local[*]") - .setAppName("test") - .set("spark.ui.enabled", "false") - .set("spark.app.id", appID) - - private var s: SparkSession = _ - - implicit def session: SparkSession = s - implicit def sc: SparkContext = session.sparkContext - implicit def sqlContext: SQLContext = session.sqlContext - - override def beforeAll(): Unit = { - assert(s == null) - s = SparkSession.builder().config(conf).getOrCreate() - } - - override def afterAll(): Unit = { - if (s != null) { - s.stop() - s = null - } - } -} - - -class TypedDatasetSuite extends AnyFunSuite with Checkers with BeforeAndAfterAll with SparkTesting { - // Limit size of generated collections and number of checks to avoid OutOfMemoryError - implicit override val generatorDrivenConfig: PropertyCheckConfiguration = { - def getPosZInt(name: String, default: PosZInt) = Properties.envOrNone(s"FRAMELESS_GEN_${name}") - .flatMap(s => Try(s.toInt).toOption) - .flatMap(PosZInt.from) - .getOrElse(default) - PropertyCheckConfiguration( - sizeRange = getPosZInt("SIZE_RANGE", PosZInt(20)), - minSize = getPosZInt("MIN_SIZE", PosZInt(0)) - ) - } - - implicit val sparkDelay: SparkDelay[Job] = Job.framelessSparkDelayForJob - - def approximatelyEqual[A](a: A, b: A)(implicit numeric: Numeric[A]): Prop = { - val da = numeric.toDouble(a) - val db = numeric.toDouble(b) - val epsilon = 1E-6 - // Spark has a weird behaviour concerning expressions that should return Inf - // Most of the time they return NaN instead, for instance stddev of Seq(-7.827553978923477E227, -5.009124275715786E153) - if((da.isNaN || da.isInfinity) && (db.isNaN || db.isInfinity)) proved - else if ( - (da - db).abs < epsilon || - (da - db).abs < da.abs / 100) - proved - else falsified :| s"Expected $a but got $b, which is more than 1% off and greater than epsilon = $epsilon." - } -} diff --git a/dataset/src/test/scala/frameless/UdtEncodedClass.scala b/dataset/src/test/scala/frameless/UdtEncodedClass.scala deleted file mode 100644 index 4e5c2c6d9..000000000 --- a/dataset/src/test/scala/frameless/UdtEncodedClass.scala +++ /dev/null @@ -1,47 +0,0 @@ -package frameless - -import org.apache.spark.sql.catalyst.InternalRow -import org.apache.spark.sql.catalyst.expressions.{GenericInternalRow, UnsafeArrayData} -import org.apache.spark.sql.types._ -import org.apache.spark.sql.FramelessInternals.UserDefinedType - -@SQLUserDefinedType(udt = classOf[UdtEncodedClassUdt]) -class UdtEncodedClass(val a: Int, val b: Array[Double]) { - override def equals(other: Any): Boolean = other match { - case that: UdtEncodedClass => a == that.a && java.util.Arrays.equals(b, that.b) - case _ => false - } - - override def hashCode(): Int = { - val state = Seq[Any](a, b) - state.map(_.hashCode()).foldLeft(0)((a, b) => 31 * a + b) - } - - override def toString = s"UdtEncodedClass($a, $b)" -} - -object UdtEncodedClass { - implicit val udtForUdtEncodedClass = new UdtEncodedClassUdt -} - -class UdtEncodedClassUdt extends UserDefinedType[UdtEncodedClass] { - def sqlType: DataType = { - StructType(Seq( - StructField("a", IntegerType, nullable = false), - StructField("b", ArrayType(DoubleType, containsNull = false), nullable = false) - )) - } - - def serialize(obj: UdtEncodedClass): InternalRow = { - val row = new GenericInternalRow(3) - row.setInt(0, obj.a) - row.update(1, UnsafeArrayData.fromPrimitiveArray(obj.b)) - row - } - - def deserialize(datum: Any): UdtEncodedClass = datum match { - case row: InternalRow => new UdtEncodedClass(row.getInt(0), row.getArray(1).toDoubleArray()) - } - - def userClass: Class[UdtEncodedClass] = classOf[UdtEncodedClass] -} diff --git a/dataset/src/test/scala/frameless/WithColumnTest.scala b/dataset/src/test/scala/frameless/WithColumnTest.scala deleted file mode 100644 index c41c4e726..000000000 --- a/dataset/src/test/scala/frameless/WithColumnTest.scala +++ /dev/null @@ -1,82 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import shapeless.test.illTyped - -class WithColumnTest extends TypedDatasetSuite { - import WithColumnTest._ - - test("fail to compile on missing value") { - val f: TypedDataset[X] = TypedDataset.create(X(1,1) :: X(1,1) :: X(1,10) :: Nil) - illTyped { - """val fNew: TypedDataset[XMissing] = f.withColumn[XMissing](f('j) === 10)""" - } - } - - test("fail to compile on different column name") { - val f: TypedDataset[X] = TypedDataset.create(X(1,1) :: X(1,1) :: X(1,10) :: Nil) - illTyped { - """val fNew: TypedDataset[XDifferentColumnName] = f.withColumn[XDifferentColumnName](f('j) === 10)""" - } - } - - test("fail to compile on added column name") { - val f: TypedDataset[X] = TypedDataset.create(X(1,1) :: X(1,1) :: X(1,10) :: Nil) - illTyped { - """val fNew: TypedDataset[XAdded] = f.withColumn[XAdded](f('j) === 10)""" - } - } - - test("fail to compile on wrong typed column") { - val f: TypedDataset[X] = TypedDataset.create(X(1,1) :: X(1,1) :: X(1,10) :: Nil) - illTyped { - """val fNew: TypedDataset[XWrongType] = f.withColumn[XWrongType](f('j) === 10)""" - } - } - - test("append four columns") { - def prop[A: TypedEncoder](value: A): Prop = { - val d = TypedDataset.create(X1(value) :: Nil) - val d1 = d.withColumn[X2[A, A]](d('a)) - val d2 = d1.withColumn[X3[A, A, A]](d1('b)) - val d3 = d2.withColumn[X4[A, A, A, A]](d2('c)) - val d4 = d3.withColumn[X5[A, A, A, A, A]](d3('d)) - - X5(value, value, value, value, value) ?= d4.collect().run().head - } - - check(prop[Int] _) - check(prop[Long] _) - check(prop[String] _) - check(prop[SQLDate] _) - check(prop[Option[X1[Boolean]]] _) - } - - test("update in place") { - def prop[A : TypedEncoder](startValue: A, replaceValue: A): Prop = { - val d = TypedDataset.create(X2(startValue, replaceValue) :: Nil) - - val X2(a, b) = d.withColumnReplaced('a, d('b)) - .collect() - .run() - .head - - a ?= b - } - check(prop[Int] _) - check(prop[Long] _) - check(prop[String] _) - check(prop[SQLDate] _) - check(prop[Option[X1[Boolean]]] _) - } -} - -object WithColumnTest { - case class X(i: Int, j: Int) - case class XMissing(i: Int, k: Boolean) - case class XDifferentColumnName(i: Int, ji: Int, k: Boolean) - case class XAdded(i: Int, j: Int, k: Boolean, l: Int) - case class XWrongType(i: Int, j: Int, k: Int) - case class XGood(i: Int, j: Int, k: Boolean) -} diff --git a/dataset/src/test/scala/frameless/WithColumnTupledTest.scala b/dataset/src/test/scala/frameless/WithColumnTupledTest.scala deleted file mode 100644 index d8c49a921..000000000 --- a/dataset/src/test/scala/frameless/WithColumnTupledTest.scala +++ /dev/null @@ -1,25 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class WithColumnTupledTest extends TypedDatasetSuite { - test("append five columns") { - def prop[A: TypedEncoder](value: A): Prop = { - val d = TypedDataset.create(X1(value) :: Nil) - val d1 = d.withColumnTupled(d('a)) - val d2 = d1.withColumnTupled(d1('_1)) - val d3 = d2.withColumnTupled(d2('_2)) - val d4 = d3.withColumnTupled(d3('_3)) - val d5 = d4.withColumnTupled(d4('_4)) - - (value, value, value, value, value, value) ?= d5.collect().run().head - } - - check(prop[Int] _) - check(prop[Long] _) - check(prop[String] _) - check(prop[SQLDate] _) - check(prop[Option[X1[Boolean]]] _) - } -} diff --git a/dataset/src/test/scala/frameless/XN.scala b/dataset/src/test/scala/frameless/XN.scala deleted file mode 100644 index 0aa7f7280..000000000 --- a/dataset/src/test/scala/frameless/XN.scala +++ /dev/null @@ -1,92 +0,0 @@ -package frameless - -import org.scalacheck.{Arbitrary, Cogen} - -case class X1[A](a: A) - -object X1 { - implicit def arbitrary[A: Arbitrary]: Arbitrary[X1[A]] = - Arbitrary(implicitly[Arbitrary[A]].arbitrary.map(X1(_))) - - implicit def cogen[A](implicit A: Cogen[A]): Cogen[X1[A]] = - A.contramap(_.a) - - implicit def ordering[A: Ordering]: Ordering[X1[A]] = Ordering[A].on(_.a) -} - -case class X2[A, B](a: A, b: B) - -object X2 { - implicit def arbitrary[A: Arbitrary, B: Arbitrary]: Arbitrary[X2[A, B]] = - Arbitrary(Arbitrary.arbTuple2[A, B].arbitrary.map((X2.apply[A, B] _).tupled)) - - implicit def cogen[A, B](implicit A: Cogen[A], B: Cogen[B]): Cogen[X2[A, B]] = - Cogen.tuple2(A, B).contramap(x => (x.a, x.b)) - - implicit def ordering[A: Ordering, B: Ordering]: Ordering[X2[A, B]] = Ordering.Tuple2[A, B].on(x => (x.a, x.b)) -} - -case class X3[A, B, C](a: A, b: B, c: C) - -object X3 { - implicit def arbitrary[A: Arbitrary, B: Arbitrary, C: Arbitrary]: Arbitrary[X3[A, B, C]] = - Arbitrary(Arbitrary.arbTuple3[A, B, C].arbitrary.map((X3.apply[A, B, C] _).tupled)) - - implicit def cogen[A, B, C](implicit A: Cogen[A], B: Cogen[B], C: Cogen[C]): Cogen[X3[A, B, C]] = - Cogen.tuple3(A, B, C).contramap(x => (x.a, x.b, x.c)) - - implicit def ordering[A: Ordering, B: Ordering, C: Ordering]: Ordering[X3[A, B, C]] = - Ordering.Tuple3[A, B, C].on(x => (x.a, x.b, x.c)) -} - -case class X3U[A, B, C](a: A, b: B, u: Unit, c: C) - -object X3U { - implicit def arbitrary[A: Arbitrary, B: Arbitrary, C: Arbitrary]: Arbitrary[X3U[A, B, C]] = - Arbitrary(Arbitrary.arbTuple3[A, B, C].arbitrary.map(x => X3U[A, B, C](x._1, x._2, (), x._3))) - - implicit def cogen[A, B, C](implicit A: Cogen[A], B: Cogen[B], C: Cogen[C]): Cogen[X3U[A, B, C]] = - Cogen.tuple3(A, B, C).contramap(x => (x.a, x.b, x.c)) - - implicit def ordering[A: Ordering, B: Ordering, C: Ordering]: Ordering[X3U[A, B, C]] = - Ordering.Tuple3[A, B, C].on(x => (x.a, x.b, x.c)) -} - -case class X4[A, B, C, D](a: A, b: B, c: C, d: D) - -object X4 { - implicit def arbitrary[A: Arbitrary, B: Arbitrary, C: Arbitrary, D: Arbitrary]: Arbitrary[X4[A, B, C, D]] = - Arbitrary(Arbitrary.arbTuple4[A, B, C, D].arbitrary.map((X4.apply[A, B, C, D] _).tupled)) - - implicit def cogen[A, B, C, D](implicit A: Cogen[A], B: Cogen[B], C: Cogen[C], D: Cogen[D]): Cogen[X4[A, B, C, D]] = - Cogen.tuple4(A, B, C, D).contramap(x => (x.a, x.b, x.c, x.d)) - - implicit def ordering[A: Ordering, B: Ordering, C: Ordering, D: Ordering]: Ordering[X4[A, B, C, D]] = - Ordering.Tuple4[A, B, C, D].on(x => (x.a, x.b, x.c, x.d)) -} - -case class X5[A, B, C, D, E](a: A, b: B, c: C, d: D, e: E) - -object X5 { - implicit def arbitrary[A: Arbitrary, B: Arbitrary, C: Arbitrary, D: Arbitrary, E: Arbitrary]: Arbitrary[X5[A, B, C, D, E]] = - Arbitrary(Arbitrary.arbTuple5[A, B, C, D, E].arbitrary.map((X5.apply[A, B, C, D, E] _).tupled)) - - implicit def cogen[A, B, C, D, E](implicit A: Cogen[A], B: Cogen[B], C: Cogen[C], D: Cogen[D], E: Cogen[E]): Cogen[X5[A, B, C, D, E]] = - Cogen.tuple5(A, B, C, D, E).contramap(x => (x.a, x.b, x.c, x.d, x.e)) - - implicit def ordering[A: Ordering, B: Ordering, C: Ordering, D: Ordering, E: Ordering]: Ordering[X5[A, B, C, D, E]] = - Ordering.Tuple5[A, B, C, D, E].on(x => (x.a, x.b, x.c, x.d, x.e)) -} - -case class X6[A, B, C, D, E, F](a: A, b: B, c: C, d: D, e: E, f: F) - -object X6 { - implicit def arbitrary[A: Arbitrary, B: Arbitrary, C: Arbitrary, D: Arbitrary, E: Arbitrary, F: Arbitrary]: Arbitrary[X6[A, B, C, D, E, F]] = - Arbitrary(Arbitrary.arbTuple6[A, B, C, D, E, F].arbitrary.map((X6.apply[A, B, C, D, E, F] _).tupled)) - - implicit def cogen[A, B, C, D, E, F](implicit A: Cogen[A], B: Cogen[B], C: Cogen[C], D: Cogen[D], E: Cogen[E], F: Cogen[F]): Cogen[X6[A, B, C, D, E, F]] = - Cogen.tuple6(A, B, C, D, E, F).contramap(x => (x.a, x.b, x.c, x.d, x.e, x.f)) - - implicit def ordering[A: Ordering, B: Ordering, C: Ordering, D: Ordering, E: Ordering, F: Ordering]: Ordering[X6[A, B, C, D, E, F]] = - Ordering.Tuple6[A, B, C, D, E, F].on(x => (x.a, x.b, x.c, x.d, x.e, x.f)) -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/forward/CheckpointTests.scala b/dataset/src/test/scala/frameless/forward/CheckpointTests.scala deleted file mode 100644 index 9a1ff8b44..000000000 --- a/dataset/src/test/scala/frameless/forward/CheckpointTests.scala +++ /dev/null @@ -1,21 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop.{forAll, _} - - -class CheckpointTests extends TypedDatasetSuite { - test("checkpoint") { - def prop[A: TypedEncoder](data: Vector[A], isEager: Boolean): Prop = { - val dataset = TypedDataset.create(data) - - dataset.sparkSession.sparkContext.setCheckpointDir(TEST_OUTPUT_DIR) - - dataset.checkpoint(isEager).run().queryExecution.toString() =? - dataset.dataset.checkpoint(isEager).queryExecution.toString() - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/forward/ColumnsTests.scala b/dataset/src/test/scala/frameless/forward/ColumnsTests.scala deleted file mode 100644 index 282a72c9a..000000000 --- a/dataset/src/test/scala/frameless/forward/ColumnsTests.scala +++ /dev/null @@ -1,30 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop.forAll - -class ColumnsTests extends TypedDatasetSuite { - test("columns") { - def prop(i: Int, s: String, b: Boolean, l: Long, d: Double, by: Byte): Prop = { - val x1 = X1(i) :: Nil - val x2 = X2(i, s) :: Nil - val x3 = X3(i, s, b) :: Nil - val x4 = X4(i, s, b, l) :: Nil - val x5 = X5(i, s, b, l, d) :: Nil - val x6 = X6(i, s, b, l, d, by) :: Nil - - val datasets = Seq(TypedDataset.create(x1), TypedDataset.create(x2), - TypedDataset.create(x3), TypedDataset.create(x4), - TypedDataset.create(x5), TypedDataset.create(x6)) - - Prop.all(datasets.flatMap { dataset => - val columns = dataset.dataset.columns - dataset.columns.map(col => - Prop.propBoolean(columns contains col) - ) - }: _*) - } - - check(forAll(prop _)) - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/forward/CountTests.scala b/dataset/src/test/scala/frameless/forward/CountTests.scala deleted file mode 100644 index f0511bc1a..000000000 --- a/dataset/src/test/scala/frameless/forward/CountTests.scala +++ /dev/null @@ -1,14 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class CountTests extends TypedDatasetSuite { - test("count") { - def prop[A: TypedEncoder](data: Vector[A]): Prop = - TypedDataset.create(data).count().run() ?= data.size.toLong - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/forward/DistinctTests.scala b/dataset/src/test/scala/frameless/forward/DistinctTests.scala deleted file mode 100644 index 44da5e59e..000000000 --- a/dataset/src/test/scala/frameless/forward/DistinctTests.scala +++ /dev/null @@ -1,16 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import math.Ordering - -class DistinctTests extends TypedDatasetSuite { - test("distinct") { - // Comparison done with `.sorted` because order is not preserved by Spark for this operation. - def prop[A: TypedEncoder : Ordering](data: Vector[A]): Prop = - TypedDataset.create(data).distinct.collect().run().toVector.sorted ?= data.distinct.sorted - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/forward/ExceptTests.scala b/dataset/src/test/scala/frameless/forward/ExceptTests.scala deleted file mode 100644 index a99fa1e7f..000000000 --- a/dataset/src/test/scala/frameless/forward/ExceptTests.scala +++ /dev/null @@ -1,23 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class ExceptTests extends TypedDatasetSuite { - test("except") { - def prop[A: TypedEncoder](data1: Set[A], data2: Set[A]): Prop = { - val dataset1 = TypedDataset.create(data1.toSeq) - val dataset2 = TypedDataset.create(data2.toSeq) - val datasetSubtract = dataset1.except(dataset2).collect().run().toVector - val dataSubtract = data1.diff(data2) - - Prop.all( - datasetSubtract.size ?= dataSubtract.size, - datasetSubtract.toSet ?= dataSubtract - ) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/forward/FirstTests.scala b/dataset/src/test/scala/frameless/forward/FirstTests.scala deleted file mode 100644 index e00a2a378..000000000 --- a/dataset/src/test/scala/frameless/forward/FirstTests.scala +++ /dev/null @@ -1,19 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import org.scalatest.matchers.should.Matchers - -class FirstTests extends TypedDatasetSuite with Matchers { - test("first") { - def prop[A: TypedEncoder](data: Vector[A]): Prop = - TypedDataset.create(data).firstOption().run() =? data.headOption - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } - - test("first on empty dataset should return None") { - TypedDataset.create(Vector[Int]()).firstOption().run() shouldBe None - } -} diff --git a/dataset/src/test/scala/frameless/forward/ForeachTests.scala b/dataset/src/test/scala/frameless/forward/ForeachTests.scala deleted file mode 100644 index 34c89b933..000000000 --- a/dataset/src/test/scala/frameless/forward/ForeachTests.scala +++ /dev/null @@ -1,39 +0,0 @@ -package frameless -package forward - -import org.apache.spark.util.CollectionAccumulator - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -import scala.collection.JavaConverters._ - -class ForeachTests extends TypedDatasetSuite { - test("foreach") { - def prop[A: Ordering: TypedEncoder](data: Vector[A]): Prop = { - val accu = new CollectionAccumulator[A]() - sc.register(accu) - - TypedDataset.create(data).foreach(accu.add).run() - - accu.value.asScala.toVector.sorted ?= data.sorted - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } - - test("foreachPartition") { - def prop[A: Ordering: TypedEncoder](data: Vector[A]): Prop = { - val accu = new CollectionAccumulator[A]() - sc.register(accu) - - TypedDataset.create(data).foreachPartition(_.foreach(accu.add)).run() - - accu.value.asScala.toVector.sorted ?= data.sorted - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/forward/HeadTests.scala b/dataset/src/test/scala/frameless/forward/HeadTests.scala deleted file mode 100644 index 63f76e003..000000000 --- a/dataset/src/test/scala/frameless/forward/HeadTests.scala +++ /dev/null @@ -1,31 +0,0 @@ -package frameless.forward - -import frameless.{TypedDataset, TypedDatasetSuite, TypedEncoder, TypedExpressionEncoder, X1} -import org.apache.spark.sql.SparkSession -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -import scala.reflect.ClassTag -import org.scalatest.matchers.should.Matchers - -class HeadTests extends TypedDatasetSuite with Matchers { - def propArray[A: TypedEncoder : ClassTag : Ordering](data: Vector[X1[A]])(implicit c: SparkSession): Prop = { - import c.implicits._ - if(data.nonEmpty) { - val tds = TypedDataset. - create(c.createDataset(data)( - TypedExpressionEncoder.apply[X1[A]] - ).orderBy($"a".desc)) - (tds.headOption().run().get ?= data.max). - &&(tds.head(1).run().head ?= data.max). - &&(tds.head(4).run().toVector ?= - data.sortBy(_.a)(implicitly[Ordering[A]].reverse).take(4)) - } else Prop.passed - } - - test("headOption(), head(1), and head(4)") { - check(propArray[Int] _) - check(propArray[Char] _) - check(propArray[String] _) - } -} diff --git a/dataset/src/test/scala/frameless/forward/InputFilesTests.scala b/dataset/src/test/scala/frameless/forward/InputFilesTests.scala deleted file mode 100644 index 246867e63..000000000 --- a/dataset/src/test/scala/frameless/forward/InputFilesTests.scala +++ /dev/null @@ -1,48 +0,0 @@ -package frameless - -import java.util.UUID - -import org.apache.spark.sql.SparkSession -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import org.scalatest.matchers.should.Matchers - -class InputFilesTests extends TypedDatasetSuite with Matchers { - test("inputFiles") { - - def propText[A: TypedEncoder](data: Vector[A]): Prop = { - val filePath = s"$TEST_OUTPUT_DIR/${UUID.randomUUID()}.txt" - - TypedDataset.create(data).dataset.write.text(filePath) - val dataset = TypedDataset.create(implicitly[SparkSession].sparkContext.textFile(filePath)) - - dataset.inputFiles sameElements dataset.dataset.inputFiles - } - - def propCsv[A: TypedEncoder](data: Vector[A]): Prop = { - val filePath = s"$TEST_OUTPUT_DIR/${UUID.randomUUID()}.csv" - val inputDataset = TypedDataset.create(data) - inputDataset.dataset.write.csv(filePath) - - val dataset = TypedDataset.createUnsafe( - implicitly[SparkSession].sqlContext.read.schema(inputDataset.schema).csv(filePath)) - - dataset.inputFiles sameElements dataset.dataset.inputFiles - } - - def propJson[A: TypedEncoder](data: Vector[A]): Prop = { - val filePath = s"$TEST_OUTPUT_DIR/${UUID.randomUUID()}.json" - val inputDataset = TypedDataset.create(data) - inputDataset.dataset.write.json(filePath) - - val dataset = TypedDataset.createUnsafe( - implicitly[SparkSession].sqlContext.read.schema(inputDataset.schema).json(filePath)) - - dataset.inputFiles sameElements dataset.dataset.inputFiles - } - - check(forAll(propText[String] _)) - check(forAll(propCsv[String] _)) - check(forAll(propJson[String] _)) - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/forward/IntersectTests.scala b/dataset/src/test/scala/frameless/forward/IntersectTests.scala deleted file mode 100644 index f0edb856e..000000000 --- a/dataset/src/test/scala/frameless/forward/IntersectTests.scala +++ /dev/null @@ -1,24 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import math.Ordering - -class IntersectTests extends TypedDatasetSuite { - test("intersect") { - def prop[A: TypedEncoder : Ordering](data1: Vector[A], data2: Vector[A]): Prop = { - val dataset1 = TypedDataset.create(data1) - val dataset2 = TypedDataset.create(data2) - val datasetIntersect = dataset1.intersect(dataset2).collect().run().toVector - - // Vector `intersect` is the multiset intersection, while Spark throws away duplicates. - val dataIntersect = data1.intersect(data2).distinct - - // Comparison done with `.sorted` because order is not preserved by Spark for this operation. - datasetIntersect.sorted ?= dataIntersect.distinct.sorted - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/forward/IsLocalTests.scala b/dataset/src/test/scala/frameless/forward/IsLocalTests.scala deleted file mode 100644 index f61d25cd1..000000000 --- a/dataset/src/test/scala/frameless/forward/IsLocalTests.scala +++ /dev/null @@ -1,17 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class IsLocalTests extends TypedDatasetSuite { - test("isLocal") { - def prop[A: TypedEncoder](data: Vector[A]): Prop = { - val dataset = TypedDataset.create(data) - - dataset.isLocal ?= dataset.dataset.isLocal - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/forward/IsStreamingTests.scala b/dataset/src/test/scala/frameless/forward/IsStreamingTests.scala deleted file mode 100644 index dd1874977..000000000 --- a/dataset/src/test/scala/frameless/forward/IsStreamingTests.scala +++ /dev/null @@ -1,17 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class IsStreamingTests extends TypedDatasetSuite { - test("isStreaming") { - def prop[A: TypedEncoder](data: Vector[A]): Prop = { - val dataset = TypedDataset.create(data) - - dataset.isStreaming ?= dataset.dataset.isStreaming - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/forward/LimitTests.scala b/dataset/src/test/scala/frameless/forward/LimitTests.scala deleted file mode 100644 index 5a4fafd88..000000000 --- a/dataset/src/test/scala/frameless/forward/LimitTests.scala +++ /dev/null @@ -1,20 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class LimitTests extends TypedDatasetSuite { - test("limit") { - def prop[A: TypedEncoder](data: Vector[A], n: Int): Prop = (n >= 0) ==> { - val dataset = TypedDataset.create(data).limit(n).collect().run() - - Prop.all( - dataset.length ?= Math.min(data.length, n), - dataset.forall(data.contains) - ) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/forward/QueryExecutionTests.scala b/dataset/src/test/scala/frameless/forward/QueryExecutionTests.scala deleted file mode 100644 index d59e250df..000000000 --- a/dataset/src/test/scala/frameless/forward/QueryExecutionTests.scala +++ /dev/null @@ -1,17 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop.{forAll, _} - -class QueryExecutionTests extends TypedDatasetSuite { - test("queryExecution") { - def prop[A: TypedEncoder](data: Vector[A]): Prop = { - val dataset = TypedDataset.create[A](data) - - dataset.queryExecution =? dataset.dataset.queryExecution - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/forward/RandomSplitTests.scala b/dataset/src/test/scala/frameless/forward/RandomSplitTests.scala deleted file mode 100644 index 4cc9a4fde..000000000 --- a/dataset/src/test/scala/frameless/forward/RandomSplitTests.scala +++ /dev/null @@ -1,39 +0,0 @@ -package frameless - -import org.scalacheck.Arbitrary.arbitrary -import org.scalacheck.Prop._ -import org.scalacheck.{Arbitrary, Gen} - -import scala.collection.JavaConverters._ -import org.scalatest.matchers.should.Matchers - -class RandomSplitTests extends TypedDatasetSuite with Matchers { - - val nonEmptyPositiveArray: Gen[Array[Double]] = Gen.nonEmptyListOf(Gen.posNum[Double]).map(_.toArray) - - test("randomSplit(weight, seed)") { - def prop[A: TypedEncoder : Arbitrary] = forAll(vectorGen[A], nonEmptyPositiveArray, arbitrary[Long]) { - (data: Vector[A], weights: Array[Double], seed: Long) => - val dataset = TypedDataset.create(data) - - dataset.randomSplit(weights, seed).map(_.count().run()) sameElements - dataset.dataset.randomSplit(weights, seed).map(_.count()) - } - - check(prop[Int]) - check(prop[String]) - } - - test("randomSplitAsList(weight, seed)") { - def prop[A: TypedEncoder : Arbitrary] = forAll(vectorGen[A], nonEmptyPositiveArray, arbitrary[Long]) { - (data: Vector[A], weights: Array[Double], seed: Long) => - val dataset = TypedDataset.create(data) - - dataset.randomSplitAsList(weights, seed).asScala.map(_.count().run()) sameElements - dataset.dataset.randomSplitAsList(weights, seed).asScala.map(_.count()) - } - - check(prop[Int]) - check(prop[String]) - } -} diff --git a/dataset/src/test/scala/frameless/forward/SQLContextTests.scala b/dataset/src/test/scala/frameless/forward/SQLContextTests.scala deleted file mode 100644 index 700f29b05..000000000 --- a/dataset/src/test/scala/frameless/forward/SQLContextTests.scala +++ /dev/null @@ -1,17 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop.{forAll, _} - -class SQLContextTests extends TypedDatasetSuite { - test("sqlContext") { - def prop[A: TypedEncoder](data: Vector[A]): Prop = { - val dataset = TypedDataset.create[A](data) - - dataset.sqlContext =? dataset.dataset.sqlContext - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/forward/SparkSessionTests.scala b/dataset/src/test/scala/frameless/forward/SparkSessionTests.scala deleted file mode 100644 index c5d0da338..000000000 --- a/dataset/src/test/scala/frameless/forward/SparkSessionTests.scala +++ /dev/null @@ -1,17 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class SparkSessionTests extends TypedDatasetSuite { - test("sparkSession") { - def prop[A: TypedEncoder](data: Vector[A]): Prop = { - val dataset = TypedDataset.create[A](data) - - dataset.sparkSession =? dataset.dataset.sparkSession - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/forward/StorageLevelTests.scala b/dataset/src/test/scala/frameless/forward/StorageLevelTests.scala deleted file mode 100644 index 3ac93773e..000000000 --- a/dataset/src/test/scala/frameless/forward/StorageLevelTests.scala +++ /dev/null @@ -1,29 +0,0 @@ -package frameless - -import org.apache.spark.storage.StorageLevel -import org.apache.spark.storage.StorageLevel._ -import org.scalacheck.Prop._ -import org.scalacheck.{Arbitrary, Gen} - -class StorageLevelTests extends TypedDatasetSuite { - - val storageLevelGen: Gen[StorageLevel] = Gen.oneOf(Seq(NONE, DISK_ONLY, DISK_ONLY_2, MEMORY_ONLY, - MEMORY_ONLY_2, MEMORY_ONLY_SER, MEMORY_ONLY_SER_2, MEMORY_AND_DISK, - MEMORY_AND_DISK_2, MEMORY_AND_DISK_SER, MEMORY_AND_DISK_SER_2, OFF_HEAP)) - - test("storageLevel") { - def prop[A: TypedEncoder : Arbitrary] = forAll(vectorGen[A], storageLevelGen) { - (data: Vector[A], storageLevel: StorageLevel) => - val dataset = TypedDataset.create(data) - if (storageLevel != StorageLevel.NONE) - dataset.persist(storageLevel) - - dataset.count().run() - - dataset.storageLevel() ?= dataset.dataset.storageLevel - } - - check(prop[Int]) - check(prop[String]) - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/forward/TakeTests.scala b/dataset/src/test/scala/frameless/forward/TakeTests.scala deleted file mode 100644 index eec77bc80..000000000 --- a/dataset/src/test/scala/frameless/forward/TakeTests.scala +++ /dev/null @@ -1,27 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import scala.reflect.ClassTag - -class TakeTests extends TypedDatasetSuite { - test("take") { - def prop[A: TypedEncoder](n: Int, data: Vector[A]): Prop = - (n >= 0) ==> (TypedDataset.create(data).take(n).run().toVector =? data.take(n)) - - def propArray[A: TypedEncoder: ClassTag](n: Int, data: Vector[X1[Array[A]]]): Prop = - (n >= 0) ==> { - Prop { - TypedDataset.create(data).take(n).run().toVector.zip(data.take(n)).forall { - case (X1(l), X1(r)) => l sameElements r - } - } - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - check(forAll(propArray[Int] _)) - check(forAll(propArray[String] _)) - check(forAll(propArray[Byte] _)) - } -} diff --git a/dataset/src/test/scala/frameless/forward/ToJSONTests.scala b/dataset/src/test/scala/frameless/forward/ToJSONTests.scala deleted file mode 100644 index 5ed79a9c9..000000000 --- a/dataset/src/test/scala/frameless/forward/ToJSONTests.scala +++ /dev/null @@ -1,17 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class ToJSONTests extends TypedDatasetSuite { - test("toJSON") { - def prop[A: TypedEncoder](data: Vector[A]): Prop = { - val dataset = TypedDataset.create(data) - - dataset.toJSON.collect().run() ?= dataset.dataset.toJSON.collect() - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/forward/ToLocalIteratorTests.scala b/dataset/src/test/scala/frameless/forward/ToLocalIteratorTests.scala deleted file mode 100644 index faaf25caf..000000000 --- a/dataset/src/test/scala/frameless/forward/ToLocalIteratorTests.scala +++ /dev/null @@ -1,19 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import scala.collection.JavaConverters._ -import org.scalatest.matchers.should.Matchers - -class ToLocalIteratorTests extends TypedDatasetSuite with Matchers { - test("toLocalIterator") { - def prop[A: TypedEncoder](data: Vector[A]): Prop = { - val dataset = TypedDataset.create(data) - - dataset.toLocalIterator().run().asScala.toIterator sameElements dataset.dataset.toLocalIterator().asScala.toIterator - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/forward/UnionTests.scala b/dataset/src/test/scala/frameless/forward/UnionTests.scala deleted file mode 100644 index 6cd8f4005..000000000 --- a/dataset/src/test/scala/frameless/forward/UnionTests.scala +++ /dev/null @@ -1,66 +0,0 @@ -package frameless - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import shapeless.test.illTyped - -class UnionTests extends TypedDatasetSuite { - - test("fail to compile on not aligned schema") { - val dataset1 = TypedDataset.create(Foo(1, 1) :: Nil) - val dataset2 = TypedDataset.create(Wrong(1, 1, 1) :: Nil) - - illTyped { - """val fNew = dataset1 union dataset2 """ - } - } - - test("Union for simple data types") { - def prop[A: TypedEncoder](data1: Vector[A], data2: Vector[A]): Prop = { - val dataset1 = TypedDataset.create(data1) - val dataset2 = TypedDataset.create(data2) - val datasetUnion = dataset1.union(dataset2).collect().run().toVector - val dataUnion = data1.union(data2) - - datasetUnion ?= dataUnion - } - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } - - test("Align fields for case classes") { - def prop[A: TypedEncoder, B: TypedEncoder](data1: Vector[(A, B)], data2: Vector[(A, B)]): Prop = { - - val dataset1 = TypedDataset.create(data1.map((Foo.apply[A, B] _).tupled)) - val dataset2 = TypedDataset.create(data2.map { case (a, b) => Bar[A, B](b, a) }) - val datasetUnion = dataset1.union(dataset2).collect().run().map(foo => (foo.x, foo.y)).toVector - val dataUnion = data1 union data2 - - datasetUnion ?= dataUnion - } - - check(forAll(prop[Int, String] _)) - check(forAll(prop[String, X1[Option[Long]]] _)) - } - - test("Align fields for different number of columns") { - def prop[A: TypedEncoder, B: TypedEncoder, C: TypedEncoder](data1: Vector[(A, B, C)], data2: Vector[(A, B)]): Prop = { - - val dataset1 = TypedDataset.create(data2.map((Foo.apply[A, B] _).tupled)) - val dataset2 = TypedDataset.create(data1.map { case (a, b, c) => Baz[A, B, C](c, b, a) }) - val datasetUnion: Seq[(A, B)] = dataset1.union(dataset2).collect().run().map(foo => (foo.x, foo.y)).toVector - val dataUnion = data2 union data1.map { case (a, b, _) => (a, b) } - - datasetUnion ?= dataUnion - } - - check(forAll(prop[Option[Int], String, Array[Long]] _)) - check(forAll(prop[String, X1[Option[Int]], X2[String, Array[Int]]] _)) - } -} - -final case class Foo[A, B](x: A, y: B) -final case class Bar[A, B](y: B, x: A) -final case class Baz[A, B, C](z: C, y: B, x: A) -final case class Wrong[A, B, C](a: A, b: B, c: C) \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/forward/WriteStreamTests.scala b/dataset/src/test/scala/frameless/forward/WriteStreamTests.scala deleted file mode 100644 index 368147c93..000000000 --- a/dataset/src/test/scala/frameless/forward/WriteStreamTests.scala +++ /dev/null @@ -1,87 +0,0 @@ -package frameless - -import java.util.UUID - -import org.apache.spark.sql.Encoder -import org.apache.spark.sql.execution.streaming.MemoryStream -import org.scalacheck.Prop._ -import org.scalacheck.{Arbitrary, Gen, Prop} - -class WriteStreamTests extends TypedDatasetSuite { - - val genNested = for { - d <- Arbitrary.arbitrary[Double] - as <- Arbitrary.arbitrary[String] - } yield Nested(d, as) - - val genOptionFieldsOnly = for { - o1 <- Gen.option(Arbitrary.arbitrary[Int]) - o2 <- Gen.option(genNested) - } yield OptionFieldsOnly(o1, o2) - - val genWriteExample = for { - i <- Arbitrary.arbitrary[Int] - s <- Arbitrary.arbitrary[String] - on <- Gen.option(genNested) - ooo <- Gen.option(genOptionFieldsOnly) - } yield WriteExample(i, s, on, ooo) - - test("write csv") { - val spark = session - import spark.implicits._ - def prop[A: TypedEncoder: Encoder](data: List[A]): Prop = { - val uid = UUID.randomUUID() - val uidNoHyphens = uid.toString.replace("-", "") - val filePath = s"$TEST_OUTPUT_DIR/$uid}" - val checkpointPath = s"$TEST_OUTPUT_DIR/checkpoint/$uid" - val inputStream = MemoryStream[A] - val input = TypedDataset.create(inputStream.toDS()) - val inputter = input.writeStream.format("csv").option("checkpointLocation", s"$checkpointPath/input").start(filePath) - inputStream.addData(data) - inputter.processAllAvailable() - val dataset = TypedDataset.createUnsafe(sqlContext.readStream.schema(input.schema).csv(filePath)) - - val tester = dataset - .writeStream - .option("checkpointLocation", s"$checkpointPath/tester") - .format("memory") - .queryName(s"testCsv_$uidNoHyphens") - .start() - tester.processAllAvailable() - val output = spark.table(s"testCsv_$uidNoHyphens").as[A] - TypedDataset.create(data).collect().run().groupBy(identity) ?= output.collect().groupBy(identity).map { case (k, arr) => (k, arr.toSeq) } - } - - check(forAll(Gen.nonEmptyListOf(Gen.alphaNumStr.suchThat(_.nonEmpty)))(prop[String])) - check(forAll(Gen.nonEmptyListOf(Arbitrary.arbitrary[Int]))(prop[Int])) - } - - test("write parquet") { - val spark = session - import spark.implicits._ - def prop[A: TypedEncoder: Encoder](data: List[A]): Prop = { - val uid = UUID.randomUUID() - val uidNoHyphens = uid.toString.replace("-", "") - val filePath = s"$TEST_OUTPUT_DIR/$uid}" - val checkpointPath = s"$TEST_OUTPUT_DIR/checkpoint/$uid" - val inputStream = MemoryStream[A] - val input = TypedDataset.create(inputStream.toDS()) - val inputter = input.writeStream.format("parquet").option("checkpointLocation", s"$checkpointPath/input").start(filePath) - inputStream.addData(data) - inputter.processAllAvailable() - val dataset = TypedDataset.createUnsafe(sqlContext.readStream.schema(input.schema).parquet(filePath)) - - val tester = dataset - .writeStream - .option("checkpointLocation", s"$checkpointPath/tester") - .format("memory") - .queryName(s"testParquet_$uidNoHyphens") - .start() - tester.processAllAvailable() - val output = spark.table(s"testParquet_$uidNoHyphens").as[A] - TypedDataset.create(data).collect().run().groupBy(identity) ?= output.collect().groupBy(identity).map { case (k, arr) => (k, arr.toSeq) } - } - - check(forAll(Gen.nonEmptyListOf(genWriteExample))(prop[WriteExample])) - } -} diff --git a/dataset/src/test/scala/frameless/forward/WriteTests.scala b/dataset/src/test/scala/frameless/forward/WriteTests.scala deleted file mode 100644 index d5a9057cb..000000000 --- a/dataset/src/test/scala/frameless/forward/WriteTests.scala +++ /dev/null @@ -1,59 +0,0 @@ -package frameless - -import java.util.UUID - -import org.scalacheck.Prop._ -import org.scalacheck.{Arbitrary, Gen, Prop} - -class WriteTests extends TypedDatasetSuite { - - val genNested = for { - d <- Arbitrary.arbitrary[Double] - as <- Arbitrary.arbitrary[String] - } yield Nested(d, as) - - val genOptionFieldsOnly = for { - o1 <- Gen.option(Arbitrary.arbitrary[Int]) - o2 <- Gen.option(genNested) - } yield OptionFieldsOnly(o1, o2) - - val genWriteExample = for { - i <- Arbitrary.arbitrary[Int] - s <- Arbitrary.arbitrary[String] - on <- Gen.option(genNested) - ooo <- Gen.option(genOptionFieldsOnly) - } yield WriteExample(i, s, on, ooo) - - test("write csv") { - def prop[A: TypedEncoder](data: List[A]): Prop = { - val filePath = s"$TEST_OUTPUT_DIR/${UUID.randomUUID()}" - val input = TypedDataset.create(data) - input.write.csv(filePath) - - val dataset = TypedDataset.createUnsafe(sqlContext.read.schema(input.schema).csv(filePath)) - - dataset.collect().run().groupBy(identity) ?= input.collect().run().groupBy(identity) - } - - check(forAll(Gen.listOf(Gen.alphaNumStr.suchThat(_.nonEmpty)))(prop[String])) - check(forAll(prop[Int] _)) - } - - test("write parquet") { - def prop[A: TypedEncoder](data: List[A]): Prop = { - val filePath = s"$TEST_OUTPUT_DIR/${UUID.randomUUID()}" - val input = TypedDataset.create(data) - input.write.parquet(filePath) - - val dataset = TypedDataset.createUnsafe(sqlContext.read.schema(input.schema).parquet(filePath)) - - dataset.collect().run().groupBy(identity) ?= input.collect().run().groupBy(identity) - } - - check(forAll(Gen.listOf(genWriteExample))(prop[WriteExample])) - } -} - -case class Nested(i: Double, v: String) -case class OptionFieldsOnly(o1: Option[Int], o2: Option[Nested]) -case class WriteExample(i: Int, s: String, on: Option[Nested], ooo: Option[OptionFieldsOnly]) diff --git a/dataset/src/test/scala/frameless/functions/AggregateFunctionsTests.scala b/dataset/src/test/scala/frameless/functions/AggregateFunctionsTests.scala deleted file mode 100644 index 8a5479eb6..000000000 --- a/dataset/src/test/scala/frameless/functions/AggregateFunctionsTests.scala +++ /dev/null @@ -1,585 +0,0 @@ -package frameless -package functions - -import frameless.{TypedAggregate, TypedColumn} -import frameless.functions.aggregate._ -import org.apache.spark.sql.{Column, Encoder} -import org.scalacheck.{Gen, Prop} -import org.scalacheck.Prop._ - -class AggregateFunctionsTests extends TypedDatasetSuite { - def sparkSchema[A: TypedEncoder, U](f: TypedColumn[X1[A], A] => TypedAggregate[X1[A], U]): Prop = { - val df = TypedDataset.create[X1[A]](Nil) - val col = f(df.col('a)) - - val sumDf = df.agg(col) - - TypedExpressionEncoder.targetStructType(sumDf.encoder) ?= sumDf.dataset.schema - } - - test("sum") { - case class Sum4Tests[A, B](sum: Seq[A] => B) - - def prop[A: TypedEncoder, Out: TypedEncoder : Numeric](xs: List[A])( - implicit - summable: CatalystSummable[A, Out], - summer: Sum4Tests[A, Out] - ): Prop = { - val dataset = TypedDataset.create(xs.map(X1(_))) - val A = dataset.col[A]('a) - - val datasetSum: List[Out] = dataset.agg(sum(A)).collect().run().toList - - datasetSum match { - case x :: Nil => approximatelyEqual(summer.sum(xs), x) - case other => falsified - } - } - - // Replicate Spark's behaviour : Ints and Shorts are cast to Long - // https://github.com/apache/spark/blob/7eb2ca8/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/Sum.scala#L37 - implicit def summerDecimal = Sum4Tests[BigDecimal, BigDecimal](_.sum) - implicit def summerDouble = Sum4Tests[Double, Double](_.sum) - implicit def summerLong = Sum4Tests[Long, Long](_.sum) - implicit def summerInt = Sum4Tests[Int, Long](_.map(_.toLong).sum) - implicit def summerShort = Sum4Tests[Short, Long](_.map(_.toLong).sum) - - check(forAll(prop[BigDecimal, BigDecimal] _)) - check(forAll(prop[Long, Long] _)) - check(forAll(prop[Double, Double] _)) - check(forAll(prop[Int, Long] _)) - check(forAll(prop[Short, Long] _)) - - check(sparkSchema[BigDecimal, BigDecimal](sum)) - check(sparkSchema[Long, Long](sum)) - check(sparkSchema[Int, Long](sum)) - check(sparkSchema[Double, Double](sum)) - check(sparkSchema[Short, Long](sum)) - } - - test("sumDistinct") { - case class Sum4Tests[A, B](sum: Seq[A] => B) - - def prop[A: TypedEncoder, Out: TypedEncoder : Numeric](xs: List[A])( - implicit - summable: CatalystSummable[A, Out], - summer: Sum4Tests[A, Out] - ): Prop = { - val dataset = TypedDataset.create(xs.map(X1(_))) - val A = dataset.col[A]('a) - - val datasetSum: List[Out] = dataset.agg(sumDistinct(A)).collect().run().toList - - datasetSum match { - case x :: Nil => approximatelyEqual(summer.sum(xs), x) - case other => falsified - } - } - - // Replicate Spark's behaviour : Ints and Shorts are cast to Long - // https://github.com/apache/spark/blob/7eb2ca8/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/Sum.scala#L37 - implicit def summerLong = Sum4Tests[Long, Long](_.toSet.sum) - implicit def summerInt = Sum4Tests[Int, Long]( x => x.toSet.map((_:Int).toLong).sum) - implicit def summerShort = Sum4Tests[Short, Long](x => x.toSet.map((_:Short).toLong).sum) - - check(forAll(prop[Long, Long] _)) - check(forAll(prop[Int, Long] _)) - check(forAll(prop[Short, Long] _)) - - check(sparkSchema[Long, Long](sum)) - check(sparkSchema[Int, Long](sum)) - check(sparkSchema[Short, Long](sum)) - } - - test("avg") { - case class Averager4Tests[A, B](avg: Seq[A] => B) - - def prop[A: TypedEncoder, Out: TypedEncoder : Numeric](xs: List[A])( - implicit - averageable: CatalystAverageable[A, Out], - averager: Averager4Tests[A, Out] - ): Prop = { - val dataset = TypedDataset.create(xs.map(X1(_))) - val A = dataset.col[A]('a) - - val datasetAvg: Vector[Out] = dataset.agg(avg(A)).collect().run().toVector - - if (datasetAvg.size > 2) falsified - else xs match { - case Nil => datasetAvg ?= Vector() - case _ :: _ => datasetAvg.headOption match { - case Some(x) => approximatelyEqual(averager.avg(xs), x) - case None => falsified - } - } - } - - // Replicate Spark's behaviour : If the datatype isn't BigDecimal cast type to Double - // https://github.com/apache/spark/blob/7eb2ca8/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/Average.scala#L50 - implicit def averageDecimal = Averager4Tests[BigDecimal, BigDecimal](as => as.sum/as.size) - implicit def averageDouble = Averager4Tests[Double, Double](as => as.sum/as.size) - implicit def averageLong = Averager4Tests[Long, Double](as => as.map(_.toDouble).sum/as.size) - implicit def averageInt = Averager4Tests[Int, Double](as => as.map(_.toDouble).sum/as.size) - implicit def averageShort = Averager4Tests[Short, Double](as => as.map(_.toDouble).sum/as.size) - - check(forAll(prop[BigDecimal, BigDecimal] _)) - check(forAll(prop[Double, Double] _)) - check(forAll(prop[Long, Double] _)) - check(forAll(prop[Int, Double] _)) - check(forAll(prop[Short, Double] _)) - } - - test("stddev and variance") { - def prop[A: TypedEncoder : CatalystVariance : Numeric](xs: List[A]): Prop = { - val numeric = implicitly[Numeric[A]] - val dataset = TypedDataset.create(xs.map(X1(_))) - val A = dataset.col[A]('a) - - val datasetStdOpt = dataset.agg(stddev(A)).collect().run().toVector.headOption - val datasetVarOpt = dataset.agg(variance(A)).collect().run().toVector.headOption - - val std = sc.parallelize(xs.map(implicitly[Numeric[A]].toDouble)).sampleStdev() - val `var` = sc.parallelize(xs.map(implicitly[Numeric[A]].toDouble)).sampleVariance() - - (datasetStdOpt, datasetVarOpt) match { - case (Some(datasetStd), Some(datasetVar)) => - approximatelyEqual(datasetStd, std) && approximatelyEqual(datasetVar, `var`) - case _ => proved - } - } - - check(forAll(prop[Short] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Double] _)) - } - - test("litAggr") { - def prop[A: TypedEncoder, B: TypedEncoder, C: TypedEncoder](xs: List[A], b: B, c: C): Prop = { - val dataset = TypedDataset.create(xs) - val (r1, rb, rc, rcount) = dataset.agg(count().lit(1), litAggr(b), litAggr(c), count()).collect().run().head - (rcount ?= xs.size.toLong) && (r1 ?= 1) && (rb ?= b) && (rc ?= c) - } - - check(forAll(prop[Boolean, Int, String] _)) - check(forAll(prop[Option[Boolean], Vector[Option[Vector[Char]]], Long] _)) - } - - test("count") { - def prop[A: TypedEncoder](xs: List[A]): Prop = { - val dataset = TypedDataset.create(xs) - val Vector(datasetCount) = dataset.agg(count()).collect().run().toVector - - datasetCount ?= xs.size.toLong - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Byte] _)) - } - - test("count('a)") { - def prop[A: TypedEncoder](xs: List[A]): Prop = { - val dataset = TypedDataset.create(xs.map(X1(_))) - val A = dataset.col[A]('a) - val datasetCount = dataset.agg(count(A)).collect().run() - - datasetCount ?= List(xs.size.toLong) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Byte] _)) - } - - test("max") { - def prop[A: TypedEncoder: CatalystOrdered](xs: List[A])(implicit o: Ordering[A]): Prop = { - val dataset = TypedDataset.create(xs.map(X1(_))) - val A = dataset.col[A]('a) - val datasetMax = dataset.agg(max(A)).collect().run().toList - - datasetMax ?= xs.reduceOption(o.max).toList - } - - check(forAll(prop[Long] _)) - check(forAll(prop[Double] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[String] _)) - } - - test("max with follow up multiplication") { - def prop(xs: List[Long]): Prop = { - val dataset = TypedDataset.create(xs.map(X1(_))) - val A = dataset.col[Long]('a) - val datasetMax = dataset.agg(max(A) * 2).collect().run().headOption - - datasetMax ?= (if(xs.isEmpty) None else Some(xs.max * 2)) - } - - check(forAll(prop _)) - } - - test("min") { - def prop[A: TypedEncoder: CatalystOrdered](xs: List[A])(implicit o: Ordering[A]): Prop = { - val dataset = TypedDataset.create(xs.map(X1(_))) - val A = dataset.col[A]('a) - - val datasetMin = dataset.agg(min(A)).collect().run().toList - - datasetMin ?= xs.reduceOption(o.min).toList - } - - check(forAll(prop[Long] _)) - check(forAll(prop[Double] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[String] _)) - } - - test("first") { - def prop[A: TypedEncoder](xs: List[A]): Prop = { - val dataset = TypedDataset.create(xs.map(X1(_))) - val A = dataset.col[A]('a) - - val datasetFirst = dataset.agg(first(A)).collect().run().toList - - datasetFirst ?= xs.headOption.toList - } - - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Double] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[String] _)) - } - - test("last") { - def prop[A: TypedEncoder](xs: List[A]): Prop = { - val dataset = TypedDataset.create(xs.map(X1(_))) - val A = dataset.col[A]('a) - - val datasetLast = dataset.agg(last(A)).collect().run().toList - - datasetLast ?= xs.lastOption.toList - } - - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Double] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[String] _)) - } - - // Generator for simplified and focused aggregation examples - def getLowCardinalityKVPairs: Gen[Vector[(Int, Int)]] = { - val kvPairGen: Gen[(Int, Int)] = for { - k <- Gen.const(1) // key - v <- Gen.choose(10, 100) // values - } yield (k, v) - - Gen.listOfN(200, kvPairGen).map(_.toVector) - } - - test("countDistinct") { - check { - forAll(getLowCardinalityKVPairs) { xs: Vector[(Int, Int)] => - val tds = TypedDataset.create(xs) - val tdsRes: Seq[(Int, Long)] = tds.groupBy(tds('_1)).agg(countDistinct(tds('_2))).collect().run() - tdsRes.toMap ?= xs.groupBy(_._1).mapValues(_.map(_._2).distinct.size.toLong).toSeq.toMap - } - } - } - - test("approxCountDistinct") { - // Simple version of #approximatelyEqual() - // Default maximum estimation error of HyperLogLog in Spark is 5% - def approxEqual(actual: Long, estimated: Long, allowedDeviationPercentile: Double = 0.05): Boolean = { - val delta: Long = Math.abs(actual - estimated) - delta / actual.toDouble < allowedDeviationPercentile * 2 - } - - check { - forAll(getLowCardinalityKVPairs) { xs: Vector[(Int, Int)] => - val tds = TypedDataset.create(xs) - val tdsRes: Seq[(Int, Long, Long)] = - tds.groupBy(tds('_1)).agg(countDistinct(tds('_2)), approxCountDistinct(tds('_2))).collect().run() - tdsRes.forall { case (_, v1, v2) => approxEqual(v1, v2) } - } - } - - check { - forAll(getLowCardinalityKVPairs) { xs: Vector[(Int, Int)] => - val tds = TypedDataset.create(xs) - val allowedError = 0.1 // 10% - val tdsRes: Seq[(Int, Long, Long)] = - tds.groupBy(tds('_1)).agg(countDistinct(tds('_2)), approxCountDistinct(tds('_2), allowedError)).collect().run() - tdsRes.forall { case (_, v1, v2) => approxEqual(v1, v2, allowedError) } - } - } - } - - test("collectList") { - def prop[A: TypedEncoder : Ordering](xs: List[X2[A, A]]): Prop = { - val tds = TypedDataset.create(xs) - val tdsRes: Seq[(A, Vector[A])] = tds.groupBy(tds('a)).agg(collectList(tds('b))).collect().run() - - tdsRes.toMap.mapValues(_.sorted) ?= xs.groupBy(_.a).mapValues(_.map(_.b).toVector.sorted) - } - - check(forAll(prop[Long] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[String] _)) - } - - test("collectSet") { - def prop[A: TypedEncoder : Ordering](xs: List[X2[A, A]]): Prop = { - val tds = TypedDataset.create(xs) - val tdsRes: Seq[(A, Vector[A])] = tds.groupBy(tds('a)).agg(collectSet(tds('b))).collect().run() - - tdsRes.toMap.mapValues(_.toSet) ?= xs.groupBy(_.a).mapValues(_.map(_.b).toSet) - } - - check(forAll(prop[Long] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[String] _)) - } - - test("lit") { - def prop[A: TypedEncoder](xs: List[X1[A]], l: A): Prop = { - val tds = TypedDataset.create(xs) - tds.select(tds('a), lit(l)).collect().run() ?= xs.map(x => (x.a, l)) - } - - check(forAll(prop[Long] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Vector[Vector[Int]]] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Vector[Byte]] _)) - check(forAll(prop[String] _)) - check(forAll(prop[Vector[Long]] _)) - check(forAll(prop[BigDecimal] _)) - } - - - def bivariatePropTemplate[A: TypedEncoder, B: TypedEncoder] - ( - xs: List[X3[Int, A, B]] - ) - ( - framelessFun: (TypedColumn[X3[Int, A, B], A], TypedColumn[X3[Int, A, B], B]) => TypedAggregate[X3[Int, A, B], Option[Double]], - sparkFun: (Column, Column) => Column - ) - ( - implicit - encEv: Encoder[(Int, A, B)], - encEv2: Encoder[(Int,Option[Double])], - evCanBeDoubleA: CatalystCast[A, Double], - evCanBeDoubleB: CatalystCast[B, Double] - ): Prop = { - - val tds = TypedDataset.create(xs) - // Typed implementation of bivar stats function - val tdBivar = tds.groupBy(tds('a)).agg(framelessFun(tds('b), tds('c))).deserialized.map(kv => - (kv._1, kv._2.flatMap(DoubleBehaviourUtils.nanNullHandler)) - ).collect().run() - - val cDF = session.createDataset(xs.map(x => (x.a, x.b, x.c))) - // Comparison implementation of bivar stats functions - val compBivar = cDF - .groupBy(cDF("_1")) - .agg(sparkFun(cDF("_2"), cDF("_3"))) - .map( - row => { - val grp = row.getInt(0) - (grp, DoubleBehaviourUtils.nanNullHandler(row.get(1))) - } - ) - - // Should be the same - tdBivar.toMap ?= compBivar.collect().toMap - } - - def univariatePropTemplate[A: TypedEncoder] - ( - xs: List[X2[Int, A]] - ) - ( - framelessFun: (TypedColumn[X2[Int, A], A]) => TypedAggregate[X2[Int, A], Option[Double]], - sparkFun: (Column) => Column - ) - ( - implicit - encEv: Encoder[(Int, A)], - encEv2: Encoder[(Int,Option[Double])], - evCanBeDoubleA: CatalystCast[A, Double] - ): Prop = { - - val tds = TypedDataset.create(xs) - //typed implementation of univariate stats function - val tdUnivar = tds.groupBy(tds('a)).agg(framelessFun(tds('b))).deserialized.map(kv => - (kv._1, kv._2.flatMap(DoubleBehaviourUtils.nanNullHandler)) - ).collect().run() - - val cDF = session.createDataset(xs.map(x => (x.a, x.b))) - // Comparison implementation of bivar stats functions - val compUnivar = cDF - .groupBy(cDF("_1")) - .agg(sparkFun(cDF("_2"))) - .map( - row => { - val grp = row.getInt(0) - (grp, DoubleBehaviourUtils.nanNullHandler(row.get(1))) - } - ) - - // Should be the same - tdUnivar.toMap ?= compUnivar.collect().toMap - } - - test("corr") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder, B: TypedEncoder](xs: List[X3[Int, A, B]])( - implicit - encEv: Encoder[(Int, A, B)], - evCanBeDoubleA: CatalystCast[A, Double], - evCanBeDoubleB: CatalystCast[B, Double] - ): Prop = bivariatePropTemplate(xs)(corr[A,B,X3[Int, A, B]],org.apache.spark.sql.functions.corr) - - check(forAll(prop[Double, Double] _)) - check(forAll(prop[Double, Int] _)) - check(forAll(prop[Int, Int] _)) - check(forAll(prop[Short, Int] _)) - check(forAll(prop[BigDecimal, Byte] _)) - } - - test("covar_pop") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder, B: TypedEncoder](xs: List[X3[Int, A, B]])( - implicit - encEv: Encoder[(Int, A, B)], - evCanBeDoubleA: CatalystCast[A, Double], - evCanBeDoubleB: CatalystCast[B, Double] - ): Prop = bivariatePropTemplate(xs)( - covarPop[A, B, X3[Int, A, B]], - org.apache.spark.sql.functions.covar_pop - ) - - check(forAll(prop[Double, Double] _)) - check(forAll(prop[Double, Int] _)) - check(forAll(prop[Int, Int] _)) - check(forAll(prop[Short, Int] _)) - check(forAll(prop[BigDecimal, Byte] _)) - } - - test("covar_samp") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder, B: TypedEncoder](xs: List[X3[Int, A, B]])( - implicit - encEv: Encoder[(Int, A, B)], - evCanBeDoubleA: CatalystCast[A, Double], - evCanBeDoubleB: CatalystCast[B, Double] - ): Prop = bivariatePropTemplate(xs)( - covarSamp[A, B, X3[Int, A, B]], - org.apache.spark.sql.functions.covar_samp - ) - - check(forAll(prop[Double, Double] _)) - check(forAll(prop[Double, Int] _)) - check(forAll(prop[Int, Int] _)) - check(forAll(prop[Short, Int] _)) - check(forAll(prop[BigDecimal, Byte] _)) - } - - test("kurtosis") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder](xs: List[X2[Int, A]])( - implicit - encEv: Encoder[(Int, A)], - evCanBeDoubleA: CatalystCast[A, Double] - ): Prop = univariatePropTemplate(xs)( - kurtosis[A, X2[Int, A]], - org.apache.spark.sql.functions.kurtosis - ) - - check(forAll(prop[Double] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - } - - test("skewness") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder](xs: List[X2[Int, A]])( - implicit - encEv: Encoder[(Int, A)], - evCanBeDoubleA: CatalystCast[A, Double] - ): Prop = univariatePropTemplate(xs)( - skewness[A, X2[Int, A]], - org.apache.spark.sql.functions.skewness - ) - - check(forAll(prop[Double] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - } - - test("stddev_pop") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder](xs: List[X2[Int, A]])( - implicit - encEv: Encoder[(Int, A)], - evCanBeDoubleA: CatalystCast[A, Double] - ): Prop = univariatePropTemplate(xs)( - stddevPop[A, X2[Int, A]], - org.apache.spark.sql.functions.stddev_pop - ) - - check(forAll(prop[Double] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - } - - test("stddev_samp") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder](xs: List[X2[Int, A]])( - implicit - encEv: Encoder[(Int, A)], - evCanBeDoubleA: CatalystCast[A, Double] - ): Prop = univariatePropTemplate(xs)( - stddevSamp[A, X2[Int, A]], - org.apache.spark.sql.functions.stddev_samp - ) - check(forAll(prop[Double] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - } -} diff --git a/dataset/src/test/scala/frameless/functions/DateTimeStringBehaviourUtils.scala b/dataset/src/test/scala/frameless/functions/DateTimeStringBehaviourUtils.scala deleted file mode 100644 index e22fe4337..000000000 --- a/dataset/src/test/scala/frameless/functions/DateTimeStringBehaviourUtils.scala +++ /dev/null @@ -1,10 +0,0 @@ -package frameless.functions - -import org.apache.spark.sql.Row - -object DateTimeStringBehaviourUtils { - val nullHandler: Row => Option[Int] = _.get(0) match { - case i: Int => Some(i) - case _ => None - } -} diff --git a/dataset/src/test/scala/frameless/functions/DoubleBehaviourUtils.scala b/dataset/src/test/scala/frameless/functions/DoubleBehaviourUtils.scala deleted file mode 100644 index f3a8be581..000000000 --- a/dataset/src/test/scala/frameless/functions/DoubleBehaviourUtils.scala +++ /dev/null @@ -1,20 +0,0 @@ -package frameless -package functions - -/** - * Some statistical functions in Spark can result in Double, Double.NaN or Null. - * This tends to break ?= of the property based testing. Use the nanNullHandler function - * here to alleviate this by mapping this NaN and Null to None. This will result in - * functioning comparison again. - */ -object DoubleBehaviourUtils { - // Mapping with this function is needed because spark uses Double.NaN for some semantics in the - // correlation function. ?= for prop testing will use == underlying and will break because Double.NaN != Double.NaN - private val nanHandler: Double => Option[Double] = value => if (!value.equals(Double.NaN)) Option(value) else None - // Making sure that null => None and does not result in 0.0d because of row.getAs[Double]'s use of .asInstanceOf - val nanNullHandler: Any => Option[Double] = { - case null => None - case d: Double => nanHandler(d) - case _ => ??? - } -} diff --git a/dataset/src/test/scala/frameless/functions/NonAggregateFunctionsTests.scala b/dataset/src/test/scala/frameless/functions/NonAggregateFunctionsTests.scala deleted file mode 100644 index 01d43ba9d..000000000 --- a/dataset/src/test/scala/frameless/functions/NonAggregateFunctionsTests.scala +++ /dev/null @@ -1,2358 +0,0 @@ -package frameless -package functions - -import java.io.File - -import frameless.functions.nonAggregate._ -import org.apache.commons.io.FileUtils -import org.apache.spark.sql.{Column, Encoder, SaveMode, functions => sparkFunctions} -import org.scalacheck.Prop._ -import org.scalacheck.{Arbitrary, Gen, Prop} - -class NonAggregateFunctionsTests extends TypedDatasetSuite { - val testTempFiles = "target/testoutput" - - - object NonNegativeGenerators { - val doubleGen = for { - s <- Gen.chooseNum(1, Int.MaxValue) - e <- Gen.chooseNum(1, Int.MaxValue) - res: Double = s.toDouble / e.toDouble - } yield res - - val intGen: Gen[Int] = Gen.chooseNum(1, Int.MaxValue) - val shortGen: Gen[Short] = Gen.chooseNum(1, Short.MaxValue) - val longGen: Gen[Long] = Gen.chooseNum(1, Long.MaxValue) - val byteGen: Gen[Byte] = Gen.chooseNum(1, Byte.MaxValue) - } - - object NonNegativeArbitraryNumericValues { - import NonNegativeGenerators._ - implicit val arbInt: Arbitrary[Int] = Arbitrary(intGen) - implicit val arbDouble: Arbitrary[Double] = Arbitrary(doubleGen) - implicit val arbLong: Arbitrary[Long] = Arbitrary(longGen) - implicit val arbShort: Arbitrary[Short] = Arbitrary(shortGen) - implicit val arbByte: Arbitrary[Byte] = Arbitrary(byteGen) - } - - override def afterAll(): Unit = { - FileUtils.deleteDirectory(new File(testTempFiles)) - super.afterAll() - } - - test("negate") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder : Encoder, B: TypedEncoder : Encoder](values: List[X1[A]])( - implicit encX1:Encoder[X1[A]], - catalystAbsolute: CatalystNumericWithJavaBigDecimal[A, B]) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.negate(cDS("a"))) - .map(_.getAs[B](0)) - .collect() - .toList - - val typedDS = TypedDataset.create(values) - val col = typedDS('a) - val res = typedDS - .select(negate(col)) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[Byte, Byte] _)) - check(forAll(prop[Short, Short] _)) - check(forAll(prop[Int, Int] _)) - check(forAll(prop[Long, Long] _)) - check(forAll(prop[BigDecimal, java.math.BigDecimal] _)) - } - - test("not") { - val spark = session - import spark.implicits._ - - def prop(values: List[X1[Boolean]], fromBase: Int, toBase: Int)(implicit encX1:Encoder[X1[Boolean]]) = { - val cDS = session.createDataset(values) - - val resCompare = cDS - .select(sparkFunctions.not(cDS("a"))) - .map(_.getAs[Boolean](0)) - .collect() - .toList - - val typedDS = TypedDataset.create(values) - val col = typedDS('a) - val res = typedDS - .select(not(col)) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop _)) - } - - test("conv") { - val spark = session - import spark.implicits._ - - def prop(values: List[X1[String]], fromBase: Int, toBase: Int)(implicit encX1:Encoder[X1[String]]) = { - val cDS = session.createDataset(values) - - val resCompare = cDS - .select(sparkFunctions.conv(cDS("a"), fromBase, toBase)) - .map(_.getAs[String](0)) - .collect() - .toList - - val typedDS = TypedDataset.create(values) - val col = typedDS('a) - val res = typedDS - .select(conv(col, fromBase, toBase)) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop _)) - } - - test("degrees") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder : Encoder](values: List[X1[A]])(implicit encX1:Encoder[X1[A]]) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.degrees(cDS("a"))) - .map(_.getAs[Double](0)) - .collect() - .toList - - val typedDS = TypedDataset.create(values) - val col = typedDS('a) - val res = typedDS - .select(degrees(col)) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[Byte] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[BigDecimal] _)) - } - - def propBitShift[A: TypedEncoder : Encoder, B: TypedEncoder : Encoder](typedDS: TypedDataset[X1[A]]) - (typedCol: TypedColumn[X1[A], B], sparkFunc: (Column,Int) => Column, numBits: Int): Prop = { - val spark = session - import spark.implicits._ - - val resCompare = typedDS.dataset - .select(sparkFunc($"a", numBits)) - .map(_.getAs[B](0)) - .collect() - .toList - - val res = typedDS - .select(typedCol) - .collect() - .run() - .toList - - res ?= resCompare - } - - test("shiftRightUnsigned") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder : Encoder, B: TypedEncoder : Encoder] - (values: List[X1[A]], numBits: Int) - (implicit catalystBitShift: CatalystBitShift[A, B], encX1: Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - propBitShift(typedDS)(shiftRightUnsigned(typedDS('a), numBits), sparkFunctions.shiftRightUnsigned, numBits) - } - - check(forAll(prop[Byte, Int] _)) - check(forAll(prop[Short, Int] _)) - check(forAll(prop[Int, Int] _)) - check(forAll(prop[Long, Long] _)) - check(forAll(prop[BigDecimal, Int] _)) - } - - test("shiftRight") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder : Encoder, B: TypedEncoder : Encoder] - (values: List[X1[A]], numBits: Int) - (implicit catalystBitShift: CatalystBitShift[A, B], encX1: Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - propBitShift(typedDS)(shiftRight(typedDS('a), numBits), sparkFunctions.shiftRight, numBits) - } - - check(forAll(prop[Byte, Int] _)) - check(forAll(prop[Short, Int] _)) - check(forAll(prop[Int, Int] _)) - check(forAll(prop[Long, Long] _)) - check(forAll(prop[BigDecimal, Int] _)) - } - - test("shiftLeft") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder : Encoder, B: TypedEncoder : Encoder] - (values: List[X1[A]], numBits: Int) - (implicit catalystBitShift: CatalystBitShift[A, B], encX1: Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - propBitShift(typedDS)(shiftLeft(typedDS('a), numBits), sparkFunctions.shiftLeft, numBits) - } - - check(forAll(prop[Byte, Int] _)) - check(forAll(prop[Short, Int] _)) - check(forAll(prop[Int, Int] _)) - check(forAll(prop[Long, Long] _)) - check(forAll(prop[BigDecimal, Int] _)) - } - - test("ceil") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder : Encoder, B: TypedEncoder : Encoder] - (values: List[X1[A]])( - implicit catalystAbsolute: CatalystRound[A, B], encX1: Encoder[X1[A]] - ) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.ceil(cDS("a"))) - .map(_.getAs[B](0)) - .collect() - .toList.map{ - case bigDecimal : java.math.BigDecimal => bigDecimal.setScale(0) - case other => other - }.asInstanceOf[List[B]] - - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(ceil(typedDS('a))) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[Int, Long] _)) - check(forAll(prop[Long, Long] _)) - check(forAll(prop[Short, Long] _)) - check(forAll(prop[Double, Long] _)) - check(forAll(prop[BigDecimal, java.math.BigDecimal] _)) - } - - test("sha2") { - val spark = session - import spark.implicits._ - - def prop(values: List[X1[Array[Byte]]])(implicit encX1: Encoder[X1[Array[Byte]]]) = { - Seq(224, 256, 384, 512).map { numBits => - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.sha2(cDS("a"), numBits)) - .map(_.getAs[String](0)) - .collect().toList - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(sha2(typedDS('a), numBits)) - .collect() - .run() - .toList - res ?= resCompare - }.reduce(_ && _) - } - - check(forAll(prop _)) - } - - test("sha1") { - val spark = session - import spark.implicits._ - - def prop(values: List[X1[Array[Byte]]])(implicit encX1: Encoder[X1[Array[Byte]]]) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.sha1(cDS("a"))) - .map(_.getAs[String](0)) - .collect().toList - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(sha1(typedDS('a))) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop _)) - } - - test("crc32") { - val spark = session - import spark.implicits._ - - def prop(values: List[X1[Array[Byte]]])(implicit encX1: Encoder[X1[Array[Byte]]]) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.crc32(cDS("a"))) - .map(_.getAs[Long](0)) - .collect() - .toList - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(crc32(typedDS('a))) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop _)) - } - - test("floor") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder : Encoder, B: TypedEncoder : Encoder] - (values: List[X1[A]])( - implicit catalystAbsolute: CatalystRound[A, B], encX1: Encoder[X1[A]] - ) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.floor(cDS("a"))) - .map(_.getAs[B](0)) - .collect() - .toList.map{ - case bigDecimal : java.math.BigDecimal => bigDecimal.setScale(0) - case other => other - }.asInstanceOf[List[B]] - - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(floor(typedDS('a))) - .collect() - .run() - .toList - - res ?= resCompare - } - check(forAll(prop[Int, Long] _)) - check(forAll(prop[Long, Long] _)) - check(forAll(prop[Short, Long] _)) - check(forAll(prop[Double, Long] _)) - check(forAll(prop[BigDecimal, java.math.BigDecimal] _)) - } - - - test("abs big decimal") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder: Encoder, B: TypedEncoder: Encoder] - (values: List[X1[A]]) - ( - implicit catalystAbsolute: CatalystNumericWithJavaBigDecimal[A, B], - encX1:Encoder[X1[A]] - )= { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.abs(cDS("a"))) - .map(_.getAs[B](0)) - .collect().toList - - val typedDS = TypedDataset.create(values) - val col = typedDS('a) - val res = typedDS - .select( - abs(col) - ) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[BigDecimal, java.math.BigDecimal] _)) - } - - test("abs") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder : Encoder] - (values: List[X1[A]]) - ( - implicit catalystAbsolute: CatalystNumericWithJavaBigDecimal[A, A], - encX1: Encoder[X1[A]] - ) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.abs(cDS("a"))) - .map(_.getAs[A](0)) - .collect().toList - - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(abs(typedDS('a))) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Double] _)) - } - - def propTrigonometric[A: CatalystNumeric: TypedEncoder : Encoder](typedDS: TypedDataset[X1[A]]) - (typedCol: TypedColumn[X1[A], Double], sparkFunc: Column => Column): Prop = { - val spark = session - import spark.implicits._ - - val resCompare = typedDS.dataset - .select(sparkFunc($"a")) - .map(_.getAs[Double](0)) - .map(DoubleBehaviourUtils.nanNullHandler) - .collect().toList - - val res = typedDS - .select(typedCol) - .deserialized - .map(DoubleBehaviourUtils.nanNullHandler) - .collect() - .run() - .toList - - res ?= resCompare - } - - test("cos") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]]) - (implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - propTrigonometric(typedDS)(cos(typedDS('a)), sparkFunctions.cos) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("cosh") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]]) - (implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - propTrigonometric(typedDS)(cosh(typedDS('a)), sparkFunctions.cosh) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("acos") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]]) - (implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - propTrigonometric(typedDS)(acos(typedDS('a)), sparkFunctions.acos) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - - - test("signum") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]]) - (implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - propTrigonometric(typedDS)(signum(typedDS('a)), sparkFunctions.signum) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("sin") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]]) - (implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - propTrigonometric(typedDS)(sin(typedDS('a)), sparkFunctions.sin) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("sinh") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]]) - (implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - propTrigonometric(typedDS)(sinh(typedDS('a)), sparkFunctions.sinh) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("asin") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]]) - (implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - propTrigonometric(typedDS)(asin(typedDS('a)), sparkFunctions.asin) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("tan") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]]) - (implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - propTrigonometric(typedDS)(tan(typedDS('a)), sparkFunctions.tan) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("tanh") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]]) - (implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - propTrigonometric(typedDS)(tanh(typedDS('a)), sparkFunctions.tanh) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - /* - * Currently not all Collection types play nice with the Encoders. - * This test needs to be readressed and Set readded to the Collection Typeclass once these issues are resolved. - * - * [[https://issues.apache.org/jira/browse/SPARK-18891]] - * [[https://issues.apache.org/jira/browse/SPARK-21204]] - */ - test("arrayContains"){ - val spark = session - import spark.implicits._ - - val listLength = 10 - val idxs = Stream.continually(Range(0, listLength)).flatten.toIterator - - abstract class Nth[A, C[A]:CatalystCollection] { - - def nth(c:C[A], idx:Int):A - } - - implicit def deriveListNth[A] : Nth[A, List] = new Nth[A, List] { - override def nth(c: List[A], idx: Int): A = c(idx) - } - - implicit def deriveSeqNth[A] : Nth[A, Seq] = new Nth[A, Seq] { - override def nth(c: Seq[A], idx: Int): A = c(idx) - } - - implicit def deriveVectorNth[A] : Nth[A, Vector] = new Nth[A, Vector] { - override def nth(c: Vector[A], idx: Int): A = c(idx) - } - - implicit def deriveArrayNth[A] : Nth[A, Array] = new Nth[A, Array] { - override def nth(c: Array[A], idx: Int): A = c(idx) - } - - - def prop[C[_] : CatalystCollection] - ( - values: C[Int], - shouldBeIn:Boolean) - ( - implicit nth:Nth[Int, C], - encEv: Encoder[C[Int]], - tEncEv: TypedEncoder[C[Int]] - ) = { - - val contained = if (shouldBeIn) nth.nth(values, idxs.next) else -1 - - val cDS = session.createDataset(List(values)) - val resCompare = cDS - .select(sparkFunctions.array_contains(cDS("value"), contained)) - .map(_.getAs[Boolean](0)) - .collect().toList - - val typedDS = TypedDataset.create(List(X1(values))) - val res = typedDS - .select(arrayContains(typedDS('a), contained)) - .collect() - .run() - .toList - - res ?= resCompare - } - - check( - forAll( - Gen.listOfN(listLength, Gen.choose(0,100)), - Gen.oneOf(true,false) - ) - (prop[List]) - ) - - /*check( Looks like there is no Typed Encoder for Seq type yet - forAll( - Gen.listOfN(listLength, Gen.choose(0,100)), - Gen.oneOf(true,false) - ) - (prop[Seq]) - )*/ - - check( - forAll( - Gen.listOfN(listLength, Gen.choose(0,100)).map(_.toVector), - Gen.oneOf(true,false) - ) - (prop[Vector]) - ) - - check( - forAll( - Gen.listOfN(listLength, Gen.choose(0,100)).map(_.toArray), - Gen.oneOf(true,false) - ) - (prop[Array]) - ) - } - - test("atan") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder] - (na: A, values: List[X1[A]])(implicit encX1: Encoder[X1[A]]) = { - val cDS = session.createDataset(X1(na) :: values) - val resCompare = cDS - .select(sparkFunctions.atan(cDS("a"))) - .map(_.getAs[Double](0)) - .map(DoubleBehaviourUtils.nanNullHandler) - .collect().toList - - val typedDS = TypedDataset.create(cDS) - val res = typedDS - .select(atan(typedDS('a))) - .deserialized - .map(DoubleBehaviourUtils.nanNullHandler) - .collect() - .run() - .toList - - val aggrTyped = typedDS.agg(atan( - frameless.functions.aggregate.first(typedDS('a))) - ).firstOption().run().get - - val aggrSpark = cDS.select( - sparkFunctions.atan(sparkFunctions.first("a")).as[Double] - ).first() - - (res ?= resCompare).&&(aggrTyped ?= aggrSpark) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("atan2") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder, - B: CatalystNumeric : TypedEncoder : Encoder](na: X2[A, B], values: List[X2[A, B]]) - (implicit encEv: Encoder[X2[A,B]]) = { - val cDS = session.createDataset(na +: values) - val resCompare = cDS - .select(sparkFunctions.atan2(cDS("a"), cDS("b"))) - .map(_.getAs[Double](0)) - .map(DoubleBehaviourUtils.nanNullHandler) - .collect().toList - - - val typedDS = TypedDataset.create(cDS) - val res = typedDS - .select(atan2(typedDS('a), typedDS('b))) - .deserialized - .map(DoubleBehaviourUtils.nanNullHandler) - .collect() - .run() - .toList - - val aggrTyped = typedDS.agg(atan2( - frameless.functions.aggregate.first(typedDS('a)), - frameless.functions.aggregate.first(typedDS('b))) - ).firstOption().run().get - - val aggrSpark = cDS.select( - sparkFunctions.atan2(sparkFunctions.first("a"),sparkFunctions.first("b")).as[Double] - ).first() - - (res ?= resCompare).&&(aggrTyped ?= aggrSpark) - } - - - check(forAll(prop[Int, Long] _)) - check(forAll(prop[Long, Int] _)) - check(forAll(prop[Short, Byte] _)) - check(forAll(prop[BigDecimal, Double] _)) - check(forAll(prop[Byte, Int] _)) - check(forAll(prop[Double, Double] _)) - } - - test("atan2LitLeft") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder] - (na: X1[A], value: List[X1[A]], lit:Double)(implicit encX1:Encoder[X1[A]]) = { - val cDS = session.createDataset(na +: value) - val resCompare = cDS - .select(sparkFunctions.atan2(lit, cDS("a"))) - .map(_.getAs[Double](0)) - .map(DoubleBehaviourUtils.nanNullHandler) - .collect().toList - - - val typedDS = TypedDataset.create(cDS) - val res = typedDS - .select(atan2(lit, typedDS('a))) - .deserialized - .map(DoubleBehaviourUtils.nanNullHandler) - .collect() - .run() - .toList - - val aggrTyped = typedDS.agg(atan2( - lit, - frameless.functions.aggregate.first(typedDS('a))) - ).firstOption().run().get - - val aggrSpark = cDS.select( - sparkFunctions.atan2(lit, sparkFunctions.first("a")).as[Double] - ).first() - - (res ?= resCompare).&&(aggrTyped ?= aggrSpark) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("atan2LitRight") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder] - (na: X1[A], value: List[X1[A]], lit:Double)(implicit encX1:Encoder[X1[A]]) = { - val cDS = session.createDataset(na +: value) - val resCompare = cDS - .select(sparkFunctions.atan2(cDS("a"), lit)) - .map(_.getAs[Double](0)) - .map(DoubleBehaviourUtils.nanNullHandler) - .collect().toList - - - val typedDS = TypedDataset.create(cDS) - val res = typedDS - .select(atan2(typedDS('a), lit)) - .deserialized - .map(DoubleBehaviourUtils.nanNullHandler) - .collect() - .run() - .toList - - val aggrTyped = typedDS.agg(atan2( - frameless.functions.aggregate.first(typedDS('a)), - lit) - ).firstOption().run().get - - val aggrSpark = cDS.select( - sparkFunctions.atan2(sparkFunctions.first("a"), lit).as[Double] - ).first() - - (res ?= resCompare).&&(aggrTyped ?= aggrSpark) - } - - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - def mathProp[A: CatalystNumeric: TypedEncoder : Encoder](typedDS: TypedDataset[X1[A]])( - typedCol: TypedColumn[X1[A], Double], sparkFunc: Column => Column - ): Prop = { - val spark = session - import spark.implicits._ - - val resCompare = typedDS.dataset - .select(sparkFunc($"a")) - .map(_.getAs[Double](0)) - .map(DoubleBehaviourUtils.nanNullHandler) - .collect().toList - - val res = typedDS - .select(typedCol) - .deserialized - .map(DoubleBehaviourUtils.nanNullHandler) - .collect() - .run() - .toList - - res ?= resCompare - } - - test("sqrt") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]])(implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - mathProp(typedDS)(sqrt(typedDS('a)), sparkFunctions.sqrt) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("crbt") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]])(implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - mathProp(typedDS)(cbrt(typedDS('a)), sparkFunctions.cbrt) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("exp") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]])(implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - mathProp(typedDS)(exp(typedDS('a)), sparkFunctions.exp) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[BigDecimal] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("md5") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder : Encoder](values: List[X1[A]]): Prop = { - val spark = session - import spark.implicits._ - - val typedDS = TypedDataset.create(values) - - val resCompare = typedDS.dataset - .select(sparkFunctions.md5($"a")) - .map(_.getAs[String](0)) - .collect().toList - - val res = typedDS - .select(md5(typedDS('a))) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[String] _)) - } - - test("factorial") { - val spark = session - - def prop(values: List[X1[Long]]): Prop = { - val spark = session - import spark.implicits._ - - val typedDS = TypedDataset.create(values) - - val resCompare = typedDS.dataset - .select(sparkFunctions.factorial($"a")) - .map(_.getAs[Long](0)) - .collect().toList - - val res = typedDS - .select(factorial(typedDS('a))) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop _)) - } - - test("round") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder : Encoder](values: List[X1[A]])( - implicit catalystNumericWithJavaBigDecimal: CatalystNumericWithJavaBigDecimal[A, A], - encX1: Encoder[X1[A]] - ) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.round(cDS("a"))) - .map(_.getAs[A](0)) - .collect().toList - - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(round(typedDS('a))) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Double] _)) - } - - test("round big decimal") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder: Encoder](values: List[X1[A]])( - implicit catalystAbsolute: CatalystNumericWithJavaBigDecimal[A, java.math.BigDecimal], - encX1:Encoder[X1[A]] - ) = { - val cDS = session.createDataset(values) - - val resCompare = cDS - .select(sparkFunctions.round(cDS("a"))) - .map(_.getAs[java.math.BigDecimal](0)) - .collect() - .toList.map(_.setScale(0)) - - val typedDS = TypedDataset.create(values) - val col = typedDS('a) - val res = typedDS - .select(round(col)) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[BigDecimal] _)) - } - - test("round with scale") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder : Encoder](values: List[X1[A]])( - implicit catalystNumericWithJavaBigDecimal: CatalystNumericWithJavaBigDecimal[A, A], - encX1: Encoder[X1[A]] - ) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.round(cDS("a"), 1)) - .map(_.getAs[A](0)) - .collect().toList - - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(round(typedDS('a), 1)) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Double] _)) - } - - test("round big decimal with scale") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder: Encoder](values: List[X1[A]])( - implicit catalystAbsolute: CatalystNumericWithJavaBigDecimal[A, java.math.BigDecimal], - encX1:Encoder[X1[A]] - ) = { - val cDS = session.createDataset(values) - - val resCompare = cDS - .select(sparkFunctions.round(cDS("a"), 0)) - .map(_.getAs[java.math.BigDecimal](0)) - .collect() - .toList.map(_.setScale(0)) - - val typedDS = TypedDataset.create(values) - val col = typedDS('a) - val res = typedDS - .select(round(col, 0)) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[BigDecimal] _)) - } - - test("bround") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder : Encoder](values: List[X1[A]])( - implicit catalystNumericWithJavaBigDecimal: CatalystNumericWithJavaBigDecimal[A, A], - encX1: Encoder[X1[A]] - ) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.bround(cDS("a"))) - .map(_.getAs[A](0)) - .collect().toList - - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(bround(typedDS('a))) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Double] _)) - } - - test("bround big decimal") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder: Encoder](values: List[X1[A]])( - implicit catalystAbsolute: CatalystNumericWithJavaBigDecimal[A, java.math.BigDecimal], - encX1:Encoder[X1[A]] - ) = { - val cDS = session.createDataset(values) - - val resCompare = cDS - .select(sparkFunctions.bround(cDS("a"))) - .map(_.getAs[java.math.BigDecimal](0)) - .collect() - .toList.map(_.setScale(0)) - - val typedDS = TypedDataset.create(values) - val col = typedDS('a) - val res = typedDS - .select(bround(col)) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[BigDecimal] _)) - } - - test("bround with scale") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder : Encoder](values: List[X1[A]])( - implicit catalystNumericWithJavaBigDecimal: CatalystNumericWithJavaBigDecimal[A, A], - encX1: Encoder[X1[A]] - ) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.bround(cDS("a"), 1)) - .map(_.getAs[A](0)) - .collect().toList - - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(bround(typedDS('a), 1)) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Double] _)) - } - - test("bround big decimal with scale") { - val spark = session - import spark.implicits._ - - def prop[A: TypedEncoder: Encoder](values: List[X1[A]])( - implicit catalystAbsolute: CatalystNumericWithJavaBigDecimal[A, java.math.BigDecimal], - encX1:Encoder[X1[A]] - ) = { - val cDS = session.createDataset(values) - - val resCompare = cDS - .select(sparkFunctions.bround(cDS("a"), 0)) - .map(_.getAs[java.math.BigDecimal](0)) - .collect() - .toList.map(_.setScale(0)) - - val typedDS = TypedDataset.create(values) - val col = typedDS('a) - val res = typedDS - .select(bround(col, 0)) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[BigDecimal] _)) - } - - test("log with base") { - val spark = session - import spark.implicits._ - import NonNegativeArbitraryNumericValues._ - - def prop[A: CatalystNumeric: TypedEncoder : Encoder]( - values: List[X1[A]], - base: Double - ): Prop = { - val spark = session - import spark.implicits._ - val typedDS = TypedDataset.create(values) - - val resCompare = typedDS.dataset - .select(sparkFunctions.log(base, $"a")) - .map(_.getAs[Double](0)) - .map(DoubleBehaviourUtils.nanNullHandler) - .collect().toList - - val res = typedDS - .select(log(base, typedDS('a))) - .deserialized - .map(DoubleBehaviourUtils.nanNullHandler) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("log") { - val spark = session - import spark.implicits._ - import NonNegativeArbitraryNumericValues._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]])(implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - mathProp(typedDS)(log(typedDS('a)), sparkFunctions.log) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("log2") { - val spark = session - import spark.implicits._ - import NonNegativeArbitraryNumericValues._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]])(implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - mathProp(typedDS)(log2(typedDS('a)), sparkFunctions.log2) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("log1p") { - val spark = session - import spark.implicits._ - import NonNegativeArbitraryNumericValues._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]])(implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - mathProp(typedDS)(log1p(typedDS('a)), sparkFunctions.log1p) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("log10") { - val spark = session - import spark.implicits._ - import NonNegativeArbitraryNumericValues._ - - def prop[A: CatalystNumeric : TypedEncoder : Encoder](values: List[X1[A]])(implicit encX1:Encoder[X1[A]]) = { - val typedDS = TypedDataset.create(values) - mathProp(typedDS)(log10(typedDS('a)), sparkFunctions.log10) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("base64") { - val spark = session - import spark.implicits._ - - def prop(values:List[X1[Array[Byte]]])(implicit encX1:Encoder[X1[Array[Byte]]]) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.base64(cDS("a"))) - .map(_.getAs[String](0)) - .collect().toList - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(base64(typedDS('a))) - .collect() - .run() - .toList - - val backAndForth = typedDS - .select(base64(unbase64(base64(typedDS('a))))) - .collect() - .run() - .toList - - (res ?= resCompare) && (res ?= backAndForth) - } - - check(forAll(prop _)) - } - - test("hypot with double") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric: TypedEncoder : Encoder]( - values: List[X1[A]], - base: Double - ): Prop = { - val spark = session - import spark.implicits._ - val typedDS = TypedDataset.create(values) - - val resCompare = typedDS.dataset - .select(sparkFunctions.hypot(base, $"a")) - .map(_.getAs[Double](0)) - .map(DoubleBehaviourUtils.nanNullHandler) - .collect().toList - - val res2 = typedDS - .select(hypot(typedDS('a), base)) - .deserialized - .map(DoubleBehaviourUtils.nanNullHandler) - .collect() - .run() - .toList - - val res = typedDS - .select(hypot(base, typedDS('a))) - .deserialized - .map(DoubleBehaviourUtils.nanNullHandler) - .collect() - .run() - .toList - - (res ?= resCompare) && (res2 ?= resCompare) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("hypot with two columns") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric: TypedEncoder : Encoder]( - values: List[X2[A, A]] - ): Prop = { - val spark = session - import spark.implicits._ - val typedDS = TypedDataset.create(values) - - val resCompare = typedDS.dataset - .select(sparkFunctions.hypot($"b", $"a")) - .map(_.getAs[Double](0)) - .map(DoubleBehaviourUtils.nanNullHandler) - .collect().toList - - val res = typedDS - .select(hypot(typedDS('b), typedDS('a))) - .deserialized - .map(DoubleBehaviourUtils.nanNullHandler) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("pow with double") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric: TypedEncoder : Encoder]( - values: List[X1[A]], - base: Double - ): Prop = { - val spark = session - import spark.implicits._ - val typedDS = TypedDataset.create(values) - - val resCompare = typedDS.dataset - .select(sparkFunctions.pow(base, $"a")) - .map(_.getAs[Double](0)) - .map(DoubleBehaviourUtils.nanNullHandler) - .collect().toList - - val res = typedDS - .select(pow(base, typedDS('a))) - .deserialized - .map(DoubleBehaviourUtils.nanNullHandler) - .collect() - .run() - .toList - - val resCompare2 = typedDS.dataset - .select(sparkFunctions.pow($"a", base)) - .map(_.getAs[Double](0)) - .map(DoubleBehaviourUtils.nanNullHandler) - .collect().toList - - val res2 = typedDS - .select(pow(typedDS('a), base)) - .deserialized - .map(DoubleBehaviourUtils.nanNullHandler) - .collect() - .run() - .toList - - (res ?= resCompare) && (res2 ?= resCompare2) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("pow with two columns") { - val spark = session - import spark.implicits._ - - def prop[A: CatalystNumeric: TypedEncoder : Encoder]( - values: List[X2[A, A]] - ): Prop = { - val spark = session - import spark.implicits._ - val typedDS = TypedDataset.create(values) - - val resCompare = typedDS.dataset - .select(sparkFunctions.pow($"b", $"a")) - .map(_.getAs[Double](0)) - .map(DoubleBehaviourUtils.nanNullHandler) - .collect().toList - - val res = typedDS - .select(pow(typedDS('b), typedDS('a))) - .deserialized - .map(DoubleBehaviourUtils.nanNullHandler) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("pmod") { - val spark = session - import spark.implicits._ - import NonNegativeArbitraryNumericValues._ - - def prop[A: CatalystNumeric: TypedEncoder : Encoder]( - values: List[X2[A, A]] - ): Prop = { - val spark = session - import spark.implicits._ - val typedDS = TypedDataset.create(values) - - val resCompare = typedDS.dataset - .select(sparkFunctions.pmod($"b", $"a")) - .map(_.getAs[A](0)) - .collect().toList - - val res = typedDS - .select(pmod(typedDS('b), typedDS('a))) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[Int] _)) - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Double] _)) - } - - test("unbase64") { - val spark = session - import spark.implicits._ - - def prop(values: List[X1[String]])(implicit encX1: Encoder[X1[String]]) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.unbase64(cDS("a"))) - .map(_.getAs[Array[Byte]](0)) - .collect().toList - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(unbase64(typedDS('a))) - .collect() - .run() - .toList - - res.map(_.toList) ?= resCompare.map(_.toList) - } - - check(forAll(prop _)) - } - - test("bin"){ - val spark = session - import spark.implicits._ - - def prop(values:List[X1[Long]])(implicit encX1:Encoder[X1[Long]]) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.bin(cDS("a"))) - .map(_.getAs[String](0)) - .collect().toList - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(bin(typedDS('a))) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop _)) - } - - test("bitwiseNOT"){ - val spark = session - import spark.implicits._ - - def prop[A: CatalystBitwise : TypedEncoder : Encoder] - (values:List[X1[A]])(implicit encX1:Encoder[X1[A]]) = { - val cDS = session.createDataset(values) - val resCompare = cDS - .select(sparkFunctions.bitwiseNOT(cDS("a"))) - .map(_.getAs[A](0)) - .collect().toList - - val typedDS = TypedDataset.create(values) - val res = typedDS - .select(bitwiseNOT(typedDS('a))) - .collect() - .run() - .toList - - res ?= resCompare - } - - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Int] _)) - } - - test("inputFileName") { - val spark = session - import spark.implicits._ - - def prop[A : TypedEncoder]( - toFile1: List[X1[A]], - toFile2: List[X1[A]], - inMem: List[X1[A]] - )(implicit x2Gen: Encoder[X2[A, String]], x3Gen: Encoder[X3[A, String, String]]) = { - - val file1Path = testTempFiles + "/file1" - val file2Path = testTempFiles + "/file2" - - val toFile1WithName = toFile1.map(x => X2(x.a, "file1")) - val toFile2WithName = toFile2.map(x => X2(x.a, "file2")) - val inMemWithName = inMem.map(x => X2(x.a, "")) - - toFile1WithName.toDS().write.mode(SaveMode.Overwrite).parquet(file1Path) - toFile2WithName.toDS().write.mode(SaveMode.Overwrite).parquet(file2Path) - - val readBackIn1 = spark.read.parquet(file1Path).as[X2[A, String]] - val readBackIn2 = spark.read.parquet(file2Path).as[X2[A, String]] - - val ds1 = TypedDataset.create(readBackIn1) - val ds2 = TypedDataset.create(readBackIn2) - val ds3 = TypedDataset.create(inMemWithName) - - val unioned = ds1.union(ds2).union(ds3) - - val withFileName = unioned.withColumn[X3[A, String, String]](inputFileName[X2[A, String]]()) - .collect() - .run() - .toVector - - val grouped = withFileName.groupBy(_.b).mapValues(_.map(_.c).toSet) - - grouped.foldLeft(passed) { (p, g) => - p && secure { g._1 match { - case "" => g._2.head == "" //Empty string if didn't come from file - case f => g._2.forall(_.contains(f)) - }}} - } - - check(forAll(prop[String] _)) - } - - test("monotonic id") { - val spark = session - import spark.implicits._ - - def prop[A : TypedEncoder](xs: List[X1[A]])(implicit x2en: Encoder[X2[A, Long]]) = { - val ds = TypedDataset.create(xs) - - val result = ds.withColumn[X2[A, Long]](monotonicallyIncreasingId()) - .collect() - .run() - .toVector - - val ids = result.map(_.b) - (ids.toSet.size ?= ids.length) && - (ids.sorted ?= ids) - } - - check(forAll(prop[String] _)) - } - - test("when") { - val spark = session - import spark.implicits._ - - def prop[A : TypedEncoder : Encoder] - (condition1: Boolean, condition2: Boolean, value1: A, value2: A, otherwise: A) = { - val ds = TypedDataset.create(X5(condition1, condition2, value1, value2, otherwise) :: Nil) - - val untypedWhen = ds.toDF() - .select( - sparkFunctions.when(sparkFunctions.col("a"), sparkFunctions.col("c")) - .when(sparkFunctions.col("b"), sparkFunctions.col("d")) - .otherwise(sparkFunctions.col("e")) - ) - .as[A] - .collect() - .toList - - val typedWhen = ds - .select( - when(ds('a), ds('c)) - .when(ds('b), ds('d)) - .otherwise(ds('e)) - ) - .collect() - .run() - .toList - - typedWhen ?= untypedWhen - } - - check(forAll(prop[Long] _)) - check(forAll(prop[Short] _)) - check(forAll(prop[Byte] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Option[Int]] _)) - } - - test("ascii") { - val spark = session - import spark.implicits._ - check(forAll { values: List[X1[String]] => - val ds = TypedDataset.create(values) - - val sparkResult = ds.toDF() - .select(sparkFunctions.ascii($"a")) - .map(_.getAs[Int](0)) - .collect() - .toVector - - val typed = ds - .select(ascii(ds('a))) - .collect() - .run() - .toVector - - typed ?= sparkResult - }) - } - - test("concat") { - val spark = session - import spark.implicits._ - - val pairs = for { - y <- Gen.alphaStr - x <- Gen.nonEmptyListOf(X2(y, y)) - } yield x - - check(forAll(pairs) { values: List[X2[String, String]] => - val ds = TypedDataset.create(values) - - val sparkResult = ds.toDF() - .select(sparkFunctions.concat($"a", $"b")) - .map(_.getAs[String](0)) - .collect() - .toVector - - val typed = ds - .select(concat(ds('a), ds('b))) - .collect() - .run() - .toVector - - (typed ?= sparkResult).&&(typed ?= values.map(x => s"${x.a}${x.b}").toVector) - }) - } - - test("concat for TypedAggregate") { - val spark = session - import frameless.functions.aggregate._ - import spark.implicits._ - val pairs = for { - y <- Gen.alphaStr - x <- Gen.nonEmptyListOf(X2(y, y)) - } yield x - - check(forAll(pairs) { values: List[X2[String, String]] => - val ds = TypedDataset.create(values) - val td = ds.agg(concat(first(ds('a)),first(ds('b)))).collect().run().toVector - val spark = ds.dataset.select(sparkFunctions.concat( - sparkFunctions.first($"a").as[String], - sparkFunctions.first($"b").as[String])).as[String].collect().toVector - td ?= spark - }) - } - - test("concat_ws") { - val spark = session - import spark.implicits._ - - val pairs = for { - y <- Gen.alphaStr - x <- Gen.nonEmptyListOf(X2(y, y)) - } yield x - - check(forAll(pairs) { values: List[X2[String, String]] => - val ds = TypedDataset.create(values) - - val sparkResult = ds.toDF() - .select(sparkFunctions.concat_ws(",", $"a", $"b")) - .map(_.getAs[String](0)) - .collect() - .toVector - - val typed = ds - .select(concatWs(",", ds('a), ds('b))) - .collect() - .run() - .toVector - - typed ?= sparkResult - }) - } - - test("concat_ws for TypedAggregate") { - val spark = session - import frameless.functions.aggregate._ - import spark.implicits._ - val pairs = for { - y <- Gen.alphaStr - x <- Gen.listOfN(10, X2(y, y)) - } yield x - - check(forAll(pairs) { values: List[X2[String, String]] => - val ds = TypedDataset.create(values) - val td = ds.agg(concatWs(",",first(ds('a)),first(ds('b)), last(ds('b)))).collect().run().toVector - val spark = ds.dataset.select(sparkFunctions.concat_ws(",", - sparkFunctions.first($"a").as[String], - sparkFunctions.first($"b").as[String], - sparkFunctions.last($"b").as[String])).as[String].collect().toVector - td ?= spark - }) - } - - test("instr") { - val spark = session - import spark.implicits._ - check(forAll(Gen.nonEmptyListOf(Gen.alphaStr)) { values: List[String] => - val ds = TypedDataset.create(values.map(x => X1(x + values.head))) - - val sparkResult = ds.toDF() - .select(sparkFunctions.instr($"a", values.head)) - .map(_.getAs[Int](0)) - .collect() - .toVector - - val typed = ds - .select(instr(ds('a), values.head)) - .collect() - .run() - .toVector - - typed ?= sparkResult - }) - } - - test("length") { - val spark = session - import spark.implicits._ - check(forAll { values: List[X1[String]] => - val ds = TypedDataset.create(values) - - val sparkResult = ds.toDF() - .select(sparkFunctions.length($"a")) - .map(_.getAs[Int](0)) - .collect() - .toVector - - val typed = ds - .select(length(ds[String]('a))) - .collect() - .run() - .toVector - - (typed ?= sparkResult).&&(values.map(_.a.length).toVector ?= typed) - }) - } - - test("levenshtein") { - val spark = session - import spark.implicits._ - check(forAll { (na: X1[String], values: List[X1[String]]) => - val ds = TypedDataset.create(na +: values) - - val sparkResult = ds.toDF() - .select(sparkFunctions.levenshtein($"a", sparkFunctions.concat($"a",sparkFunctions.lit("Hello")))) - .map(_.getAs[Int](0)) - .collect() - .toVector - - val typed = ds - .select(levenshtein(ds('a), concat(ds('a),lit("Hello")))) - .collect() - .run() - .toVector - - val cDS = ds.dataset - val aggrTyped = ds.agg( - levenshtein(frameless.functions.aggregate.first(ds('a)), litAggr("Hello")) - ).firstOption().run().get - - val aggrSpark = cDS.select( - sparkFunctions.levenshtein(sparkFunctions.first("a"), sparkFunctions.lit("Hello")).as[Int] - ).first() - - (typed ?= sparkResult).&&(aggrTyped ?= aggrSpark) - }) - } - - test("regexp_replace") { - val spark = session - import spark.implicits._ - check(forAll { (values: List[X1[String]], n: Int) => - val ds = TypedDataset.create(values.map(x => X1(s"$n${x.a}-$n$n"))) - - val sparkResult = ds.toDF() - .select(sparkFunctions.regexp_replace($"a", "\\d+", "n")) - .map(_.getAs[String](0)) - .collect() - .toVector - - val typed = ds - .select(regexpReplace(ds[String]('a), "\\d+".r, "n")) - .collect() - .run() - .toVector - - typed ?= sparkResult - }) - } - - test("reverse") { - val spark = session - import spark.implicits._ - check(forAll { values: List[X1[String]] => - val ds = TypedDataset.create(values) - - val sparkResult = ds.toDF() - .select(sparkFunctions.reverse($"a")) - .map(_.getAs[String](0)) - .collect() - .toVector - - val typed = ds - .select(reverse(ds[String]('a))) - .collect() - .run() - .toVector - - (typed ?= sparkResult).&&(values.map(_.a.reverse).toVector ?= typed) - }) - } - - test("rpad") { - val spark = session - import spark.implicits._ - check(forAll { values: List[X1[String]] => - val ds = TypedDataset.create(values) - - val sparkResult = ds.toDF() - .select(sparkFunctions.rpad($"a", 5, "hello")) - .map(_.getAs[String](0)) - .collect() - .toVector - - val typed = ds - .select(rpad(ds[String]('a), 5, "hello")) - .collect() - .run() - .toVector - - typed ?= sparkResult - }) - } - - test("lpad") { - val spark = session - import spark.implicits._ - check(forAll { values: List[X1[String]] => - val ds = TypedDataset.create(values) - - val sparkResult = ds.toDF() - .select(sparkFunctions.lpad($"a", 5, "hello")) - .map(_.getAs[String](0)) - .collect() - .toVector - - val typed = ds - .select(lpad(ds[String]('a), 5, "hello")) - .collect() - .run() - .toVector - - typed ?= sparkResult - }) - } - - test("rtrim") { - val spark = session - import spark.implicits._ - check(forAll { values: List[X1[String]] => - val ds = TypedDataset.create(values.map(x => X1(s" ${x.a} "))) - - val sparkResult = ds.toDF() - .select(sparkFunctions.rtrim($"a")) - .map(_.getAs[String](0)) - .collect() - .toVector - - val typed = ds - .select(rtrim(ds[String]('a))) - .collect() - .run() - .toVector - - typed ?= sparkResult - }) - } - - test("ltrim") { - val spark = session - import spark.implicits._ - check(forAll { values: List[X1[String]] => - val ds = TypedDataset.create(values.map(x => X1(s" ${x.a} "))) - - val sparkResult = ds.toDF() - .select(sparkFunctions.ltrim($"a")) - .map(_.getAs[String](0)) - .collect() - .toVector - - val typed = ds - .select(ltrim(ds[String]('a))) - .collect() - .run() - .toVector - - typed ?= sparkResult - }) - } - - test("substring") { - val spark = session - import spark.implicits._ - check(forAll { values: List[X1[String]] => - val ds = TypedDataset.create(values) - - val sparkResult = ds.toDF() - .select(sparkFunctions.substring($"a", 5, 3)) - .map(_.getAs[String](0)) - .collect() - .toVector - - val typed = ds - .select(substring(ds[String]('a), 5, 3)) - .collect() - .run() - .toVector - - typed ?= sparkResult - }) - } - - test("trim") { - val spark = session - import spark.implicits._ - check(forAll { values: List[X1[String]] => - val ds = TypedDataset.create(values.map(x => X1(s" ${x.a} "))) - - val sparkResult = ds.toDF() - .select(sparkFunctions.trim($"a")) - .map(_.getAs[String](0)) - .collect() - .toVector - - val typed = ds - .select(trim(ds[String]('a))) - .collect() - .run() - .toVector - - typed ?= sparkResult - }) - } - - test("upper") { - val spark = session - import spark.implicits._ - check(forAll(Gen.listOf(Gen.alphaStr)) { values: List[String] => - val ds = TypedDataset.create(values.map(X1(_))) - - val sparkResult = ds.toDF() - .select(sparkFunctions.upper($"a")) - .map(_.getAs[String](0)) - .collect() - .toVector - - val typed = ds - .select(upper(ds[String]('a))) - .collect() - .run() - .toVector - - typed ?= sparkResult - }) - } - - test("lower") { - val spark = session - import spark.implicits._ - check(forAll(Gen.listOf(Gen.alphaStr)) { values: List[String] => - val ds = TypedDataset.create(values.map(X1(_))) - - val sparkResult = ds.toDF() - .select(sparkFunctions.lower($"a")) - .map(_.getAs[String](0)) - .collect() - .toVector - - val typed = ds - .select(lower(ds[String]('a))) - .collect() - .run() - .toVector - - typed ?= sparkResult - }) - } - - test("Empty vararg tests") { - def prop[A : TypedEncoder, B: TypedEncoder](data: Vector[X2[A, B]]) = { - val ds = TypedDataset.create(data) - val frameless = ds.select(ds('a), concat(), ds('b), concatWs(":")).collect().run().toVector - val framelessAggr = ds.agg(concat(), concatWs("x"), litAggr(2)).collect().run().toVector - val scala = data.map(x => (x.a, "", x.b, "")) - val scalaAggr = Vector(("", "", 2)) - (frameless ?= scala).&&(framelessAggr ?= scalaAggr) - } - - check(forAll(prop[Long, Long] _)) - check(forAll(prop[Option[Boolean], Long] _)) - } - - def dateTimeStringProp(typedDS: TypedDataset[X1[String]]) - (typedCol: TypedColumn[X1[String], Option[Int]], sparkFunc: Column => Column): Prop = { - val spark = session - import spark.implicits._ - - val sparkResult = typedDS.dataset - .select(sparkFunc($"a")) - .map(DateTimeStringBehaviourUtils.nullHandler) - .collect() - .toList - - val typed = typedDS - .select(typedCol) - .collect() - .run() - .toList - - typed ?= sparkResult - } - - test("year") { - val spark = session - import spark.implicits._ - - def prop(data: List[X1[String]])(implicit E: Encoder[Option[Int]]): Prop = { - val ds = TypedDataset.create(data) - dateTimeStringProp(ds)(year(ds[String]('a)), sparkFunctions.year) - } - - check(forAll(dateTimeStringGen)(data => prop(data.map(X1.apply)))) - check(forAll(prop _)) - } - - test("quarter") { - val spark = session - import spark.implicits._ - - def prop(data: List[X1[String]])(implicit E: Encoder[Option[Int]]): Prop = { - val ds = TypedDataset.create(data) - dateTimeStringProp(ds)(quarter(ds[String]('a)), sparkFunctions.quarter) - } - - check(forAll(dateTimeStringGen)(data => prop(data.map(X1.apply)))) - check(forAll(prop _)) - } - - test("month") { - val spark = session - import spark.implicits._ - - def prop(data: List[X1[String]])(implicit E: Encoder[Option[Int]]): Prop = { - val ds = TypedDataset.create(data) - dateTimeStringProp(ds)(month(ds[String]('a)), sparkFunctions.month) - } - - check(forAll(dateTimeStringGen)(data => prop(data.map(X1.apply)))) - check(forAll(prop _)) - } - - test("dayofweek") { - val spark = session - import spark.implicits._ - - def prop(data: List[X1[String]])(implicit E: Encoder[Option[Int]]): Prop = { - val ds = TypedDataset.create(data) - dateTimeStringProp(ds)(dayofweek(ds[String]('a)), sparkFunctions.dayofweek) - } - - check(forAll(dateTimeStringGen)(data => prop(data.map(X1.apply)))) - check(forAll(prop _)) - } - - test("dayofmonth") { - val spark = session - import spark.implicits._ - - def prop(data: List[X1[String]])(implicit E: Encoder[Option[Int]]): Prop = { - val ds = TypedDataset.create(data) - dateTimeStringProp(ds)(dayofmonth(ds[String]('a)), sparkFunctions.dayofmonth) - } - - check(forAll(dateTimeStringGen)(data => prop(data.map(X1.apply)))) - check(forAll(prop _)) - } - - test("dayofyear") { - val spark = session - import spark.implicits._ - - def prop(data: List[X1[String]])(implicit E: Encoder[Option[Int]]): Prop = { - val ds = TypedDataset.create(data) - dateTimeStringProp(ds)(dayofyear(ds[String]('a)), sparkFunctions.dayofyear) - } - - check(forAll(dateTimeStringGen)(data => prop(data.map(X1.apply)))) - check(forAll(prop _)) - } - - test("hour") { - val spark = session - import spark.implicits._ - - def prop(data: List[X1[String]])(implicit E: Encoder[Option[Int]]): Prop = { - val ds = TypedDataset.create(data) - dateTimeStringProp(ds)(hour(ds[String]('a)), sparkFunctions.hour) - } - - check(forAll(dateTimeStringGen)(data => prop(data.map(X1.apply)))) - check(forAll(prop _)) - } - - test("minute") { - val spark = session - import spark.implicits._ - - def prop(data: List[X1[String]])(implicit E: Encoder[Option[Int]]): Prop = { - val ds = TypedDataset.create(data) - dateTimeStringProp(ds)(minute(ds[String]('a)), sparkFunctions.minute) - } - - check(forAll(dateTimeStringGen)(data => prop(data.map(X1.apply)))) - check(forAll(prop _)) - } - - test("second") { - val spark = session - import spark.implicits._ - - def prop(data: List[X1[String]])(implicit E: Encoder[Option[Int]]): Prop = { - val ds = TypedDataset.create(data) - dateTimeStringProp(ds)(second(ds[String]('a)), sparkFunctions.second) - } - - check(forAll(dateTimeStringGen)(data => prop(data.map(X1.apply)))) - check(forAll(prop _)) - } - - test("weekofyear") { - val spark = session - import spark.implicits._ - - def prop(data: List[X1[String]])(implicit E: Encoder[Option[Int]]): Prop = { - val ds = TypedDataset.create(data) - dateTimeStringProp(ds)(weekofyear(ds[String]('a)), sparkFunctions.weekofyear) - } - - check(forAll(dateTimeStringGen)(data => prop(data.map(X1.apply)))) - check(forAll(prop _)) - } -} diff --git a/dataset/src/test/scala/frameless/functions/UdfTests.scala b/dataset/src/test/scala/frameless/functions/UdfTests.scala deleted file mode 100644 index 10e65180f..000000000 --- a/dataset/src/test/scala/frameless/functions/UdfTests.scala +++ /dev/null @@ -1,185 +0,0 @@ -package frameless -package functions - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class UdfTests extends TypedDatasetSuite { - - test("one argument udf") { - def prop[A: TypedEncoder, B: TypedEncoder](data: Vector[X1[A]], f1: A => B): Prop = { - val dataset: TypedDataset[X1[A]] = TypedDataset.create(data) - val u1 = udf[X1[A], A, B](f1) - val u2 = dataset.makeUDF(f1) - val A = dataset.col[A]('a) - - // filter forces whole codegen - val codegen = dataset.deserialized.filter((_:X1[A]) => true).select(u1(A)).collect().run().toVector - - // otherwise it uses local relation - val local = dataset.select(u2(A)).collect().run().toVector - - val d = data.map(x => f1(x.a)) - - (codegen ?= d) && (local ?= d) - } - - check(forAll(prop[Int, Int] _)) - check(forAll(prop[String, String] _)) - check(forAll(prop[Option[Int], Option[Int]] _)) - check(forAll(prop[X1[Int], X1[Int]] _)) - check(forAll(prop[X1[Option[Int]], X1[Option[Int]]] _)) - - // TODO doesn't work for the same reason as `collect` - // check(forAll(prop[X1[Option[X1[Int]]], X1[Option[X1[Option[Int]]]]] _)) - - check(forAll(prop[Option[Vector[String]], Option[Vector[String]]] _)) - - def prop2[A: TypedEncoder, B: TypedEncoder](f: A => B)(a: A): Prop = prop(Vector(X1(a)), f) - - check(forAll(prop2[Int, Option[Int]](x => if (x % 2 == 0) Some(x) else None) _)) - check(forAll(prop2[Option[Int], Int](x => x getOrElse 0) _)) - } - - test("multiple one argument udf") { - def prop[A: TypedEncoder, B: TypedEncoder, C: TypedEncoder] - (data: Vector[X3[A, B, C]], f1: A => A, f2: B => B, f3: C => C): Prop = { - val dataset = TypedDataset.create(data) - val u11 = udf[X3[A, B, C], A, A](f1) - val u21 = udf[X3[A, B, C], B, B](f2) - val u31 = udf[X3[A, B, C], C, C](f3) - val u12 = dataset.makeUDF(f1) - val u22 = dataset.makeUDF(f2) - val u32 = dataset.makeUDF(f3) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - - val dataset21 = dataset.select(u11(A), u21(B), u31(C)).collect().run().toVector - val dataset22 = dataset.select(u12(A), u22(B), u32(C)).collect().run().toVector - val d = data.map(x => (f1(x.a), f2(x.b), f3(x.c))) - - (dataset21 ?= d) && (dataset22 ?= d) - } - - check(forAll(prop[Int, Int, Int] _)) - check(forAll(prop[String, Int, Int] _)) - check(forAll(prop[X3[Int, String, Boolean], Int, Int] _)) - check(forAll(prop[X3U[Int, String, Boolean], Int, Int] _)) - } - - test("two argument udf") { - def prop[A: TypedEncoder, B: TypedEncoder, C: TypedEncoder] - (data: Vector[X3[A, B, C]], f1: (A, B) => C): Prop = { - val dataset = TypedDataset.create(data) - val u1 = udf[X3[A, B, C], A, B, C](f1) - val u2 = dataset.makeUDF(f1) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - - val dataset21 = dataset.select(u1(A, B)).collect().run().toVector - val dataset22 = dataset.select(u2(A, B)).collect().run().toVector - val d = data.map(x => f1(x.a, x.b)) - - (dataset21 ?= d) && (dataset22 ?= d) - } - - check(forAll(prop[Int, Int, Int] _)) - check(forAll(prop[String, Int, Int] _)) - } - - test("multiple two argument udf") { - def prop[A: TypedEncoder, B: TypedEncoder, C: TypedEncoder] - (data: Vector[X3[A, B, C]], f1: (A, B) => C, f2: (B, C) => A): Prop = { - val dataset = TypedDataset.create(data) - val u11 = udf[X3[A, B, C], A, B, C](f1) - val u12 = dataset.makeUDF(f1) - val u21 = udf[X3[A, B, C], B, C, A](f2) - val u22 = dataset.makeUDF(f2) - - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - - val dataset21 = dataset.select(u11(A, B), u21(B, C)).collect().run().toVector - val dataset22 = dataset.select(u12(A, B), u22(B, C)).collect().run().toVector - val d = data.map(x => (f1(x.a, x.b), f2(x.b, x.c))) - - (dataset21 ?= d) && (dataset22 ?= d) - } - - check(forAll(prop[Int, Int, Int] _)) - check(forAll(prop[String, Int, Int] _)) - } - - test("three argument udf") { - def prop[A: TypedEncoder, B: TypedEncoder, C: TypedEncoder] - (data: Vector[X3[A, B, C]], f: (A, B, C) => C): Prop = { - val dataset = TypedDataset.create(data) - val u1 = udf[X3[A, B, C], A, B, C, C](f) - val u2 = dataset.makeUDF(f) - - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - - val dataset21 = dataset.select(u1(A, B, C)).collect().run().toVector - val dataset22 = dataset.select(u2(A, B, C)).collect().run().toVector - val d = data.map(x => f(x.a, x.b, x.c)) - - (dataset21 ?= d) && (dataset22 ?= d) - } - - check(forAll(prop[Int, Int, Int] _)) - check(forAll(prop[String, Int, Int] _)) - } - - test("four argument udf") { - def prop[A: TypedEncoder, B: TypedEncoder, C: TypedEncoder, D: TypedEncoder] - (data: Vector[X4[A, B, C, D]], f: (A, B, C, D) => C): Prop = { - val dataset = TypedDataset.create(data) - val u1 = udf[X4[A, B, C, D], A, B, C, D, C](f) - val u2 = dataset.makeUDF(f) - - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - val D = dataset.col[D]('d) - - val dataset21 = dataset.select(u1(A, B, C, D)).collect().run().toVector - val dataset22 = dataset.select(u2(A, B, C, D)).collect().run().toVector - val d = data.map(x => f(x.a, x.b, x.c, x.d)) - - (dataset21 ?= d) && (dataset22 ?= d) - } - - check(forAll(prop[Int, Int, Int, Int] _)) - check(forAll(prop[String, Int, Int, String] _)) - check(forAll(prop[String, String, String, String] _)) - check(forAll(prop[String, Long, String, String] _)) - check(forAll(prop[String, Boolean, Boolean, String] _)) - } - - test("five argument udf") { - def prop[A: TypedEncoder, B: TypedEncoder, C: TypedEncoder, D: TypedEncoder, E: TypedEncoder] - (data: Vector[X5[A, B, C, D, E]], f: (A, B, C, D, E) => C): Prop = { - val dataset = TypedDataset.create(data) - val u1 = udf[X5[A, B, C, D, E], A, B, C, D, E, C](f) - val u2 = dataset.makeUDF(f) - - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - val D = dataset.col[D]('d) - val E = dataset.col[E]('e) - - val dataset21 = dataset.select(u1(A, B, C, D, E)).collect().run().toVector - val dataset22 = dataset.select(u2(A, B, C, D, E)).collect().run().toVector - val d = data.map(x => f(x.a, x.b, x.c, x.d, x.e)) - - (dataset21 ?= d) && (dataset22 ?= d) - } - - check(forAll(prop[Int, Int, Int, Int, Int] _)) - } -} diff --git a/dataset/src/test/scala/frameless/functions/UnaryFunctionsTest.scala b/dataset/src/test/scala/frameless/functions/UnaryFunctionsTest.scala deleted file mode 100644 index 009179be6..000000000 --- a/dataset/src/test/scala/frameless/functions/UnaryFunctionsTest.scala +++ /dev/null @@ -1,141 +0,0 @@ -package frameless -package functions - -import org.scalacheck.{ Arbitrary, Prop } -import org.scalacheck.Prop._ -import scala.collection.SeqLike - -import scala.math.Ordering -import scala.reflect.ClassTag - -class UnaryFunctionsTest extends TypedDatasetSuite { - test("size tests") { - def prop[F[X] <: Traversable[X] : CatalystSizableCollection, A](xs: List[X1[F[A]]])(implicit arb: Arbitrary[F[A]], enc: TypedEncoder[F[A]]): Prop = { - val tds = TypedDataset.create(xs) - - val framelessResults = tds.select(size(tds('a))).collect().run().toVector - val scalaResults = xs.map(x => x.a.size).toVector - - framelessResults ?= scalaResults - } - - check(forAll(prop[Vector, Long] _)) - check(forAll(prop[List, Long] _)) - check(forAll(prop[Vector, Char] _)) - check(forAll(prop[List, Char] _)) - check(forAll(prop[Vector, X2[Int, Option[Long]]] _)) - check(forAll(prop[List, X2[Int, Option[Long]]] _)) - } - - test("size on array test") { - def prop[A: TypedEncoder: ClassTag](xs: List[X1[Array[A]]]): Prop = { - val tds = TypedDataset.create(xs) - - val framelessResults = tds.select(size(tds('a))).collect().run().toVector - val scalaResults = xs.map(x => x.a.size).toVector - - framelessResults ?= scalaResults - } - - check(forAll(prop[Long] _)) - check(forAll(prop[String] _)) - check(forAll(prop[X2[Int, Option[Long]]] _)) - } - - test("size on Map") { - def prop[A](xs: List[X1[Map[A, A]]])(implicit arb: Arbitrary[Map[A, A]], enc: TypedEncoder[Map[A, A]]): Prop = { - val tds = TypedDataset.create(xs) - - val framelessResults = tds.select(size(tds('a))).collect().run().toVector - val scalaResults = xs.map(x => x.a.size).toVector - - framelessResults ?= scalaResults - } - - check(forAll(prop[Long] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[Char] _)) - } - - test("sort in ascending order") { - def prop[F[X] <: SeqLike[X, F[X]] : CatalystSortableCollection, A: Ordering](xs: List[X1[F[A]]])(implicit enc: TypedEncoder[F[A]]): Prop = { - val tds = TypedDataset.create(xs) - - val framelessResults = tds.select(sortAscending(tds('a))).collect().run().toVector - val scalaResults = xs.map(x => x.a.sorted).toVector - - framelessResults ?= scalaResults - } - - check(forAll(prop[Vector, Long] _)) - check(forAll(prop[Vector, Int] _)) - check(forAll(prop[Vector, Char] _)) - check(forAll(prop[Vector, String] _)) - check(forAll(prop[List, Long] _)) - check(forAll(prop[List, Int] _)) - check(forAll(prop[List, Char] _)) - check(forAll(prop[List, String] _)) - } - - test("sort in descending order") { - def prop[F[X] <: SeqLike[X, F[X]] : CatalystSortableCollection, A: Ordering](xs: List[X1[F[A]]])(implicit enc: TypedEncoder[F[A]]): Prop = { - val tds = TypedDataset.create(xs) - - val framelessResults = tds.select(sortDescending(tds('a))).collect().run().toVector - val scalaResults = xs.map(x => x.a.sorted.reverse).toVector - - framelessResults ?= scalaResults - } - - check(forAll(prop[Vector, Long] _)) - check(forAll(prop[Vector, Int] _)) - check(forAll(prop[Vector, Char] _)) - check(forAll(prop[Vector, String] _)) - check(forAll(prop[List, Long] _)) - check(forAll(prop[List, Int] _)) - check(forAll(prop[List, Char] _)) - check(forAll(prop[List, String] _)) - } - - test("sort on array test: ascending order") { - def prop[A: TypedEncoder : Ordering : ClassTag](xs: List[X1[Array[A]]]): Prop = { - val tds = TypedDataset.create(xs) - - val framelessResults = tds.select(sortAscending(tds('a))).collect().run().toVector - val scalaResults = xs.map(x => x.a.sorted).toVector - - Prop { - framelessResults - .zip(scalaResults) - .forall { - case (a, b) => a sameElements b - } - } - } - - check(forAll(prop[Long] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } - - test("sort on array test: descending order") { - def prop[A: TypedEncoder : Ordering : ClassTag](xs: List[X1[Array[A]]]): Prop = { - val tds = TypedDataset.create(xs) - - val framelessResults = tds.select(sortDescending(tds('a))).collect().run().toVector - val scalaResults = xs.map(x => x.a.sorted.reverse).toVector - - Prop { - framelessResults - .zip(scalaResults) - .forall { - case (a, b) => a sameElements b - } - } - } - - check(forAll(prop[Long] _)) - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/ops/ColumnTypesTest.scala b/dataset/src/test/scala/frameless/ops/ColumnTypesTest.scala deleted file mode 100644 index 303eb2cbd..000000000 --- a/dataset/src/test/scala/frameless/ops/ColumnTypesTest.scala +++ /dev/null @@ -1,27 +0,0 @@ -package frameless -package ops - -import org.scalacheck.Prop -import org.scalacheck.Prop.forAll -import shapeless.HNil -import shapeless.:: - -class ColumnTypesTest extends TypedDatasetSuite { - test("test summoning") { - def prop[A: TypedEncoder, B: TypedEncoder, C: TypedEncoder, D: TypedEncoder](data: Vector[X4[A, B, C, D]]): Prop = { - val d: TypedDataset[X4[A, B, C, D]] = TypedDataset.create(data) - val hlist = d('a) :: d('b) :: d('c) :: d('d) :: HNil - - type TC[N] = TypedColumn[X4[A,B,C,D], N] - - type IN = TC[A] :: TC[B] :: TC[C] :: TC[D] :: HNil - type OUT = A :: B :: C :: D :: HNil - - implicitly[ColumnTypes.Aux[X4[A,B,C,D], IN, OUT]] - Prop.passed // successful compilation implies test correctness - } - - check(forAll(prop[Int, String, X1[String], Boolean] _)) - check(forAll(prop[Vector[Int], Vector[Vector[String]], X1[String], Option[String]] _)) - } -} diff --git a/dataset/src/test/scala/frameless/ops/CubeTests.scala b/dataset/src/test/scala/frameless/ops/CubeTests.scala deleted file mode 100644 index eb389c556..000000000 --- a/dataset/src/test/scala/frameless/ops/CubeTests.scala +++ /dev/null @@ -1,370 +0,0 @@ -package frameless -package ops - -import frameless.functions.aggregate._ -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class CubeTests extends TypedDatasetSuite { - - test("cube('a).agg(count())") { - def prop[A: TypedEncoder : Ordering, Out: TypedEncoder : Numeric] - (data: List[X1[A]])(implicit summable: CatalystSummable[A, Out]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val received = dataset.cube(A).agg(count()).collect().run().toVector.sortBy(_._2) - val expected = dataset.dataset.cube("a").count().collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[Long](1))).sortBy(_._2) - - received ?= expected - } - - check(forAll(prop[Int, Long] _)) - } - - test("cube('a, 'b).agg(count())") { - def prop[A: TypedEncoder : Ordering, B: TypedEncoder, Out: TypedEncoder : Numeric] - (data: List[X2[A, B]])(implicit summable: CatalystSummable[B, Out]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - - val received = dataset.cube(A, B).agg(count()).collect().run().toVector.sortBy(_._3) - val expected = dataset.dataset.cube("a", "b").count().collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[Long](2))).sortBy(_._3) - - received ?= expected - } - - check(forAll(prop[Int, Long, Long] _)) - } - - test("cube('a).agg(sum('b)") { - def prop[A: TypedEncoder : Ordering, B: TypedEncoder, Out: TypedEncoder : Numeric] - (data: List[X2[A, B]])(implicit summable: CatalystSummable[B, Out]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - - val received = dataset.cube(A).agg(sum(B)).collect().run().toVector.sortBy(_._2) - val expected = dataset.dataset.cube("a").sum("b").collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[Out](1))).sortBy(_._2) - - received ?= expected - } - - check(forAll(prop[Int, Long, Long] _)) - } - - test("cube('a).mapGroups('a, sum('b))") { - def prop[A: TypedEncoder : Ordering, B: TypedEncoder : Numeric] - (data: List[X2[A, B]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val received = dataset.cube(A) - .deserialized.mapGroups { case (a, xs) => (a, xs.map(_.b).sum) } - .collect().run().toVector.sortBy(_._1) - val expected = data.groupBy(_.a).mapValues(_.map(_.b).sum).toVector.sortBy(_._1) - - received ?= expected - } - - check(forAll(prop[Int, Long] _)) - } - - test("cube('a).agg(sum('b), sum('c)) to cube('a).agg(sum('a), sum('b), sum('a), sum('b), sum('a))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder, - C: TypedEncoder, - OutB: TypedEncoder : Numeric, - OutC: TypedEncoder : Numeric - ](data: List[X3[A, B, C]])( - implicit - summableB: CatalystSummable[B, OutB], - summableC: CatalystSummable[C, OutC] - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - - val framelessSumBC = dataset - .cube(A) - .agg(sum(B), sum(C)) - .collect().run().toVector.sortBy(_._1) - - val sparkSumBC = dataset.dataset.cube("a").sum("b", "c").collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[OutB](1), row.getAs[OutC](2))) - .sortBy(_._1) - - val framelessSumBCB = dataset - .cube(A) - .agg(sum(B), sum(C), sum(B)) - .collect().run().toVector.sortBy(_._1) - - val sparkSumBCB = dataset.dataset.cube("a").sum("b", "c", "b").collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[OutB](1), row.getAs[OutC](2), row.getAs[OutB](3))) - .sortBy(_._1) - - val framelessSumBCBC = dataset - .cube(A) - .agg(sum(B), sum(C), sum(B), sum(C)) - .collect().run().toVector.sortBy(_._1) - - val sparkSumBCBC = dataset.dataset.cube("a").sum("b", "c", "b", "c").collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[OutB](1), row.getAs[OutC](2), row.getAs[OutB](3), row.getAs[OutC](4))) - .sortBy(_._1) - - val framelessSumBCBCB = dataset - .cube(A) - .agg(sum(B), sum(C), sum(B), sum(C), sum(B)) - .collect().run().toVector.sortBy(_._1) - - val sparkSumBCBCB = dataset.dataset.cube("a").sum("b", "c", "b", "c", "b").collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[OutB](1), row.getAs[OutC](2), row.getAs[OutB](3), row.getAs[OutC](4), row.getAs[OutB](5))) - .sortBy(_._1) - - (framelessSumBC ?= sparkSumBC) - .&&(framelessSumBCB ?= sparkSumBCB) - .&&(framelessSumBCBC ?= sparkSumBCBC) - .&&(framelessSumBCBCB ?= sparkSumBCBCB) - } - - check(forAll(prop[String, Long, Double, Long, Double] _)) - } - - test("cube('a, 'b).agg(sum('c), sum('d))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering, - C: TypedEncoder, - D: TypedEncoder, - OutC: TypedEncoder : Numeric, - OutD: TypedEncoder : Numeric - ](data: List[X4[A, B, C, D]])( - implicit - summableC: CatalystSummable[C, OutC], - summableD: CatalystSummable[D, OutD] - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - val D = dataset.col[D]('d) - - val framelessSumByAB = dataset - .cube(A, B) - .agg(sum(C), sum(D)) - .collect().run().toVector.sortBy(x => (x._1, x._2)) - - val sparkSumByAB = dataset.dataset - .cube("a", "b").sum("c", "d").collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[OutC](2), row.getAs[OutD](3))) - .sortBy(x => (x._1, x._2)) - - framelessSumByAB ?= sparkSumByAB - } - - check(forAll(prop[Byte, Int, Long, Double, Long, Double] _)) - } - - test("cube('a, 'b).agg(sum('c)) to cube('a, 'b).agg(sum('c),sum('c),sum('c),sum('c),sum('c))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering, - C: TypedEncoder, - OutC: TypedEncoder: Numeric - ](data: List[X3[A, B, C]])(implicit summableC: CatalystSummable[C, OutC]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - - val framelessSumC = dataset - .cube(A, B) - .agg(sum(C)) - .collect().run().toVector - .sortBy(_._2) - - val sparkSumC = dataset.dataset - .cube("a", "b").sum("c").collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[OutC](2))) - .sortBy(_._2) - - val framelessSumCC = dataset - .cube(A, B) - .agg(sum(C), sum(C)) - .collect().run().toVector - .sortBy(_._2) - - val sparkSumCC = dataset.dataset - .cube("a", "b").sum("c", "c").collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[OutC](2), row.getAs[OutC](3))) - .sortBy(_._2) - - val framelessSumCCC = dataset - .cube(A, B) - .agg(sum(C), sum(C), sum(C)) - .collect().run().toVector - .sortBy(_._2) - - val sparkSumCCC = dataset.dataset - .cube("a", "b").sum("c", "c", "c").collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[OutC](2), row.getAs[OutC](3), row.getAs[OutC](4))) - .sortBy(_._2) - - val framelessSumCCCC = dataset - .cube(A, B) - .agg(sum(C), sum(C), sum(C), sum(C)) - .collect().run().toVector - .sortBy(_._2) - - val sparkSumCCCC = dataset.dataset - .cube("a", "b").sum("c", "c", "c", "c").collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[OutC](2), row.getAs[OutC](3), row.getAs[OutC](4), row.getAs[OutC](5))) - .sortBy(_._2) - - val framelessSumCCCCC = dataset - .cube(A, B) - .agg(sum(C), sum(C), sum(C), sum(C), sum(C)) - .collect().run().toVector - .sortBy(_._2) - - val sparkSumCCCCC = dataset.dataset - .cube("a", "b").sum("c", "c", "c", "c", "c").collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[OutC](2), row.getAs[OutC](3), row.getAs[OutC](4), row.getAs[OutC](5), row.getAs[OutC](6))) - .sortBy(_._2) - - (framelessSumC ?= sparkSumC) && - (framelessSumCC ?= sparkSumCC) && - (framelessSumCCC ?= sparkSumCCC) && - (framelessSumCCCC ?= sparkSumCCCC) && - (framelessSumCCCCC ?= sparkSumCCCCC) - } - - check(forAll(prop[String, Long, Double, Double] _)) - } - - test("cube('a, 'b).mapGroups('a, 'b, sum('c))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering, - C: TypedEncoder : Numeric - ](data: List[X3[A, B, C]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - - val framelessSumByAB = dataset - .cube(A, B) - .deserialized.mapGroups { case ((a, b), xs) => (a, b, xs.map(_.c).sum) } - .collect().run().toVector.sortBy(x => (x._1, x._2)) - - val sumByAB = data.groupBy(x => (x.a, x.b)) - .mapValues { xs => xs.map(_.c).sum } - .toVector.map { case ((a, b), c) => (a, b, c) }.sortBy(x => (x._1, x._2)) - - framelessSumByAB ?= sumByAB - } - - check(forAll(prop[Byte, Int, Long] _)) - } - - test("cube('a).mapGroups(('a, toVector(('a, 'b))") { - def prop[ - A: TypedEncoder, - B: TypedEncoder - ](data: Vector[X2[A, B]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val datasetGrouped = dataset - .cube(A) - .deserialized.mapGroups((a, xs) => (a, xs.toVector)) - .collect().run().toMap - - val dataGrouped = data.groupBy(_.a) - - datasetGrouped ?= dataGrouped - } - - check(forAll(prop[Short, Option[Short]] _)) - check(forAll(prop[Option[Short], Short] _)) - check(forAll(prop[X1[Option[Short]], Short] _)) - } - - test("cube('a).flatMapGroups(('a, toVector(('a, 'b))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering - ](data: Vector[X2[A, B]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val datasetGrouped = dataset - .cube(A) - .deserialized.flatMapGroups((a, xs) => xs.map(x => (a, x))) - .collect().run() - .sorted - - val dataGrouped = data - .groupBy(_.a).toSeq - .flatMap { case (a, xs) => xs.map(x => (a, x)) } - .sorted - - datasetGrouped ?= dataGrouped - } - - check(forAll(prop[Short, Option[Short]] _)) - check(forAll(prop[Option[Short], Short] _)) - check(forAll(prop[X1[Option[Short]], Short] _)) - } - - test("cube('a, 'b).flatMapGroups((('a,'b) toVector((('a,'b), 'c))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering, - C: TypedEncoder : Ordering - ](data: Vector[X3[A, B, C]]): Prop = { - val dataset = TypedDataset.create(data) - val cA = dataset.col[A]('a) - val cB = dataset.col[B]('b) - - val datasetGrouped = dataset - .cube(cA, cB) - .deserialized.flatMapGroups((a, xs) => xs.map(x => (a, x))) - .collect().run() - .sorted - - val dataGrouped = data - .groupBy(t => (t.a, t.b)).toSeq - .flatMap { case (a, xs) => xs.map(x => (a, x)) } - .sorted - - datasetGrouped ?= dataGrouped - } - - check(forAll(prop[Short, Option[Short], Long] _)) - check(forAll(prop[Option[Short], Short, Int] _)) - check(forAll(prop[X1[Option[Short]], Short, Byte] _)) - } - - test("cubeMany('a).agg(sum('b))") { - def prop[A: TypedEncoder : Ordering, Out: TypedEncoder : Numeric] - (data: List[X1[A]])(implicit summable: CatalystSummable[A, Out]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val received = dataset.cubeMany(A).agg(count[X1[A]]()).collect().run().toVector.sortBy(_._2) - val expected = dataset.dataset.cube("a").count().collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[Long](1))).sortBy(_._2) - - received ?= expected - } - - check(forAll(prop[Int, Long] _)) - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/ops/PivotTest.scala b/dataset/src/test/scala/frameless/ops/PivotTest.scala deleted file mode 100644 index dd9bf5e61..000000000 --- a/dataset/src/test/scala/frameless/ops/PivotTest.scala +++ /dev/null @@ -1,98 +0,0 @@ -package frameless -package ops - -import frameless.functions.aggregate._ -import org.apache.spark.sql.{functions => sparkFunctions} -import org.scalacheck.Arbitrary.arbitrary -import org.scalacheck.Prop._ -import org.scalacheck.{Gen, Prop} - -class PivotTest extends TypedDatasetSuite { - def withCustomGenX4: Gen[Vector[X4[String, String, Int, Boolean]]] = { - val kvPairGen: Gen[X4[String, String, Int, Boolean]] = for { - a <- Gen.oneOf(Seq("1", "2", "3", "4")) - b <- Gen.oneOf(Seq("a", "b", "c")) - c <- arbitrary[Int] - d <- arbitrary[Boolean] - } yield X4(a, b, c, d) - - Gen.listOfN(4, kvPairGen).map(_.toVector) - } - - test("X4[Boolean, String, Int, Boolean] pivot on String") { - def prop(data: Vector[X4[String, String, Int, Boolean]]): Prop = { - val d = TypedDataset.create(data) - val frameless = d.groupBy(d('a)). - pivot(d('b)).on("a", "b", "c"). - agg(sum(d('c)), first(d('d))).collect().run().toVector - - val spark = d.dataset.groupBy("a") - .pivot("b", Seq("a", "b", "c")) - .agg(sparkFunctions.sum("c"), sparkFunctions.first("d")).collect().toVector - - (frameless.map(_._1) ?= spark.map(x => x.getAs[String](0))).&&( - frameless.map(_._2) ?= spark.map(x => Option(x.getAs[Long](1)))).&&( - frameless.map(_._3) ?= spark.map(x => Option(x.getAs[Boolean](2)))).&&( - frameless.map(_._4) ?= spark.map(x => Option(x.getAs[Long](3)))).&&( - frameless.map(_._5) ?= spark.map(x => Option(x.getAs[Boolean](4)))).&&( - frameless.map(_._6) ?= spark.map(x => Option(x.getAs[Long](5)))).&&( - frameless.map(_._7) ?= spark.map(x => Option(x.getAs[Boolean](6)))) - } - - check(forAll(withCustomGenX4)(prop)) - } - - test("Pivot on Boolean") { - val x: Seq[X3[String, Boolean, Boolean]] = Seq(X3("a", true, true), X3("a", true, true), X3("a", true, false)) - val d = TypedDataset.create(x) - d.groupByMany(d('a)). - pivot(d('c)).on(true, false). - agg(count[X3[String, Boolean, Boolean]]()). - collect().run().toVector ?= Vector(("a", Some(2L), Some(1L))) // two true one false - } - - test("Pivot with groupBy on two columns, pivot on Long") { - val x: Seq[X3[String, String, Long]] = Seq(X3("a", "x", 1), X3("a", "x", 1), X3("a", "c", 20)) - val d = TypedDataset.create(x) - d.groupBy(d('a), d('b)). - pivot(d('c)).on(1L, 20L). - agg(count[X3[String, String, Long]]()). - collect().run().toSet ?= Set(("a", "x", Some(2L), None), ("a", "c", None, Some(1L))) - } - - test("Pivot with cube on two columns, pivot on Long") { - val x: Seq[X3[String, String, Long]] = Seq(X3("a", "x", 1), X3("a", "x", 1), X3("a", "c", 20)) - val d = TypedDataset.create(x) - d.cube(d('a), d('b)) - .pivot(d('c)).on(1L, 20L) - .agg(count[X3[String, String, Long]]()) - .collect().run().toSet ?= Set(("a", "x", Some(2L), None), ("a", "c", None, Some(1L))) - } - - test("Pivot with cube on Boolean") { - val x: Seq[X3[String, Boolean, Boolean]] = Seq(X3("a", true, true), X3("a", true, true), X3("a", true, false)) - val d = TypedDataset.create(x) - d.cube(d('a)). - pivot(d('c)).on(true, false). - agg(count[X3[String, Boolean, Boolean]]()). - collect().run().toVector ?= Vector(("a", Some(2L), Some(1L))) - } - - test("Pivot with rollup on two columns, pivot on Long") { - val x: Seq[X3[String, String, Long]] = Seq(X3("a", "x", 1), X3("a", "x", 1), X3("a", "c", 20)) - val d = TypedDataset.create(x) - d.rollup(d('a), d('b)) - .pivot(d('c)).on(1L, 20L) - .agg(count[X3[String, String, Long]]()) - .collect().run().toSet ?= Set(("a", "x", Some(2L), None), ("a", "c", None, Some(1L))) - } - - test("Pivot with rollup on Boolean") { - val x: Seq[X3[String, Boolean, Boolean]] = Seq(X3("a", true, true), X3("a", true, true), X3("a", true, false)) - val d = TypedDataset.create(x) - d.rollupMany(d('a)). - pivot(d('c)).on(true, false). - agg(count[X3[String, Boolean, Boolean]]()). - collect().run().toVector ?= Vector(("a", Some(2L), Some(1L))) - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/ops/RepeatTest.scala b/dataset/src/test/scala/frameless/ops/RepeatTest.scala deleted file mode 100644 index 78dfc6410..000000000 --- a/dataset/src/test/scala/frameless/ops/RepeatTest.scala +++ /dev/null @@ -1,18 +0,0 @@ -package frameless -package ops - -import shapeless.test.illTyped -import shapeless.{::, HNil, Nat} - -class RepeatTest extends TypedDatasetSuite { - test("summoning with implicitly") { - implicitly[Repeat.Aux[Int::Boolean::HNil, Nat._1, Int::Boolean::HNil]] - implicitly[Repeat.Aux[Int::Boolean::HNil, Nat._2, Int::Boolean::Int::Boolean::HNil]] - implicitly[Repeat.Aux[Int::Boolean::HNil, Nat._3, Int::Boolean::Int::Boolean::Int::Boolean::HNil]] - implicitly[Repeat.Aux[String::HNil, Nat._5, String::String::String::String::String::HNil]] - } - - test("ill typed") { - illTyped("""implicitly[Repeat.Aux[String::HNil, Nat._5, String::String::String::String::HNil]]""") - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/ops/RollupTests.scala b/dataset/src/test/scala/frameless/ops/RollupTests.scala deleted file mode 100644 index fd68646f3..000000000 --- a/dataset/src/test/scala/frameless/ops/RollupTests.scala +++ /dev/null @@ -1,370 +0,0 @@ -package frameless -package ops - -import frameless.functions.aggregate._ -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class RollupTests extends TypedDatasetSuite { - - test("rollup('a).agg(count())") { - def prop[A: TypedEncoder : Ordering, Out: TypedEncoder : Numeric] - (data: List[X1[A]])(implicit summable: CatalystSummable[A, Out]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val received = dataset.rollup(A).agg(count()).collect().run().toVector.sortBy(_._2) - val expected = dataset.dataset.rollup("a").count().collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[Long](1))).sortBy(_._2) - - received ?= expected - } - - check(forAll(prop[Int, Long] _)) - } - - test("rollup('a, 'b).agg(count())") { - def prop[A: TypedEncoder : Ordering, B: TypedEncoder, Out: TypedEncoder : Numeric] - (data: List[X2[A, B]])(implicit summable: CatalystSummable[B, Out]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - - val received = dataset.rollup(A, B).agg(count()).collect().run().toVector.sortBy(_._3) - val expected = dataset.dataset.rollup("a", "b").count().collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[Long](2))).sortBy(_._3) - - received ?= expected - } - - check(forAll(prop[Int, Long, Long] _)) - } - - test("rollup('a).agg(sum('b)") { - def prop[A: TypedEncoder : Ordering, B: TypedEncoder, Out: TypedEncoder : Numeric] - (data: List[X2[A, B]])(implicit summable: CatalystSummable[B, Out]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - - val received = dataset.rollup(A).agg(sum(B)).collect().run().toVector.sortBy(_._2) - val expected = dataset.dataset.rollup("a").sum("b").collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[Out](1))).sortBy(_._2) - - received ?= expected - } - - check(forAll(prop[Int, Long, Long] _)) - } - - test("rollup('a).mapGroups('a, sum('b))") { - def prop[A: TypedEncoder : Ordering, B: TypedEncoder : Numeric] - (data: List[X2[A, B]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val received = dataset.rollup(A) - .deserialized.mapGroups { case (a, xs) => (a, xs.map(_.b).sum) } - .collect().run().toVector.sortBy(_._1) - val expected = data.groupBy(_.a).mapValues(_.map(_.b).sum).toVector.sortBy(_._1) - - received ?= expected - } - - check(forAll(prop[Int, Long] _)) - } - - test("rollup('a).agg(sum('b), sum('c)) to rollup('a).agg(sum('a), sum('b), sum('a), sum('b), sum('a))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder, - C: TypedEncoder, - OutB: TypedEncoder : Numeric, - OutC: TypedEncoder : Numeric - ](data: List[X3[A, B, C]])( - implicit - summableB: CatalystSummable[B, OutB], - summableC: CatalystSummable[C, OutC] - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - - val framelessSumBC = dataset - .rollup(A) - .agg(sum(B), sum(C)) - .collect().run().toVector.sortBy(_._1) - - val sparkSumBC = dataset.dataset.rollup("a").sum("b", "c").collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[OutB](1), row.getAs[OutC](2))) - .sortBy(_._1) - - val framelessSumBCB = dataset - .rollup(A) - .agg(sum(B), sum(C), sum(B)) - .collect().run().toVector.sortBy(_._1) - - val sparkSumBCB = dataset.dataset.rollup("a").sum("b", "c", "b").collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[OutB](1), row.getAs[OutC](2), row.getAs[OutB](3))) - .sortBy(_._1) - - val framelessSumBCBC = dataset - .rollup(A) - .agg(sum(B), sum(C), sum(B), sum(C)) - .collect().run().toVector.sortBy(_._1) - - val sparkSumBCBC = dataset.dataset.rollup("a").sum("b", "c", "b", "c").collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[OutB](1), row.getAs[OutC](2), row.getAs[OutB](3), row.getAs[OutC](4))) - .sortBy(_._1) - - val framelessSumBCBCB = dataset - .rollup(A) - .agg(sum(B), sum(C), sum(B), sum(C), sum(B)) - .collect().run().toVector.sortBy(_._1) - - val sparkSumBCBCB = dataset.dataset.rollup("a").sum("b", "c", "b", "c", "b").collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[OutB](1), row.getAs[OutC](2), row.getAs[OutB](3), row.getAs[OutC](4), row.getAs[OutB](5))) - .sortBy(_._1) - - (framelessSumBC ?= sparkSumBC) - .&&(framelessSumBCB ?= sparkSumBCB) - .&&(framelessSumBCBC ?= sparkSumBCBC) - .&&(framelessSumBCBCB ?= sparkSumBCBCB) - } - - check(forAll(prop[String, Long, Double, Long, Double] _)) - } - - test("rollup('a, 'b).agg(sum('c), sum('d))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering, - C: TypedEncoder, - D: TypedEncoder, - OutC: TypedEncoder : Numeric, - OutD: TypedEncoder : Numeric - ](data: List[X4[A, B, C, D]])( - implicit - summableC: CatalystSummable[C, OutC], - summableD: CatalystSummable[D, OutD] - ): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - val D = dataset.col[D]('d) - - val framelessSumByAB = dataset - .rollup(A, B) - .agg(sum(C), sum(D)) - .collect().run().toVector.sortBy(_._2) - - val sparkSumByAB = dataset.dataset - .rollup("a", "b").sum("c", "d").collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[OutC](2), row.getAs[OutD](3))) - .sortBy(_._2) - - framelessSumByAB ?= sparkSumByAB - } - - check(forAll(prop[Byte, Int, Long, Double, Long, Double] _)) - } - - test("rollup('a, 'b).agg(sum('c)) to rollup('a, 'b).agg(sum('c),sum('c),sum('c),sum('c),sum('c))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering, - C: TypedEncoder, - OutC: TypedEncoder: Numeric - ](data: List[X3[A, B, C]])(implicit summableC: CatalystSummable[C, OutC]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - val C = dataset.col[C]('c) - - val framelessSumC = dataset - .rollup(A, B) - .agg(sum(C)) - .collect().run().toVector - .sortBy(_._2) - - val sparkSumC = dataset.dataset - .rollup("a", "b").sum("c").collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[OutC](2))) - .sortBy(_._2) - - val framelessSumCC = dataset - .rollup(A, B) - .agg(sum(C), sum(C)) - .collect().run().toVector - .sortBy(_._2) - - val sparkSumCC = dataset.dataset - .rollup("a", "b").sum("c", "c").collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[OutC](2), row.getAs[OutC](3))) - .sortBy(_._2) - - val framelessSumCCC = dataset - .rollup(A, B) - .agg(sum(C), sum(C), sum(C)) - .collect().run().toVector - .sortBy(_._2) - - val sparkSumCCC = dataset.dataset - .rollup("a", "b").sum("c", "c", "c").collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[OutC](2), row.getAs[OutC](3), row.getAs[OutC](4))) - .sortBy(_._2) - - val framelessSumCCCC = dataset - .rollup(A, B) - .agg(sum(C), sum(C), sum(C), sum(C)) - .collect().run().toVector - .sortBy(_._2) - - val sparkSumCCCC = dataset.dataset - .rollup("a", "b").sum("c", "c", "c", "c").collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[OutC](2), row.getAs[OutC](3), row.getAs[OutC](4), row.getAs[OutC](5))) - .sortBy(_._2) - - val framelessSumCCCCC = dataset - .rollup(A, B) - .agg(sum(C), sum(C), sum(C), sum(C), sum(C)) - .collect().run().toVector - .sortBy(_._2) - - val sparkSumCCCCC = dataset.dataset - .rollup("a", "b").sum("c", "c", "c", "c", "c").collect().toVector - .map(row => (Option(row.getAs[A](0)), Option(row.getAs[B](1)), row.getAs[OutC](2), row.getAs[OutC](3), row.getAs[OutC](4), row.getAs[OutC](5), row.getAs[OutC](6))) - .sortBy(_._2) - - (framelessSumC ?= sparkSumC) && - (framelessSumCC ?= sparkSumCC) && - (framelessSumCCC ?= sparkSumCCC) && - (framelessSumCCCC ?= sparkSumCCCC) && - (framelessSumCCCCC ?= sparkSumCCCCC) - } - - check(forAll(prop[String, Long, Double, Double] _)) - } - - test("rollup('a, 'b).mapGroups('a, 'b, sum('c))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering, - C: TypedEncoder : Numeric - ](data: List[X3[A, B, C]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - val B = dataset.col[B]('b) - - val framelessSumByAB = dataset - .rollup(A, B) - .deserialized.mapGroups { case ((a, b), xs) => (a, b, xs.map(_.c).sum) } - .collect().run().toVector.sortBy(x => (x._1, x._2)) - - val sumByAB = data.groupBy(x => (x.a, x.b)) - .mapValues { xs => xs.map(_.c).sum } - .toVector.map { case ((a, b), c) => (a, b, c) }.sortBy(x => (x._1, x._2)) - - framelessSumByAB ?= sumByAB - } - - check(forAll(prop[Byte, Int, Long] _)) - } - - test("rollup('a).mapGroups(('a, toVector(('a, 'b))") { - def prop[ - A: TypedEncoder, - B: TypedEncoder - ](data: Vector[X2[A, B]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val datasetGrouped = dataset - .rollup(A) - .deserialized.mapGroups((a, xs) => (a, xs.toVector)) - .collect().run().toMap - - val dataGrouped = data.groupBy(_.a) - - datasetGrouped ?= dataGrouped - } - - check(forAll(prop[Short, Option[Short]] _)) - check(forAll(prop[Option[Short], Short] _)) - check(forAll(prop[X1[Option[Short]], Short] _)) - } - - test("rollup('a).flatMapGroups(('a, toVector(('a, 'b))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering - ](data: Vector[X2[A, B]]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val datasetGrouped = dataset - .rollup(A) - .deserialized.flatMapGroups((a, xs) => xs.map(x => (a, x))) - .collect().run() - .sorted - - val dataGrouped = data - .groupBy(_.a).toSeq - .flatMap { case (a, xs) => xs.map(x => (a, x)) } - .sorted - - datasetGrouped ?= dataGrouped - } - - check(forAll(prop[Short, Option[Short]] _)) - check(forAll(prop[Option[Short], Short] _)) - check(forAll(prop[X1[Option[Short]], Short] _)) - } - - test("rollup('a, 'b).flatMapGroups((('a,'b) toVector((('a,'b), 'c))") { - def prop[ - A: TypedEncoder : Ordering, - B: TypedEncoder : Ordering, - C: TypedEncoder : Ordering - ](data: Vector[X3[A, B, C]]): Prop = { - val dataset = TypedDataset.create(data) - val cA = dataset.col[A]('a) - val cB = dataset.col[B]('b) - - val datasetGrouped = dataset - .rollup(cA, cB) - .deserialized.flatMapGroups((a, xs) => xs.map(x => (a, x))) - .collect().run() - .sorted - - val dataGrouped = data - .groupBy(t => (t.a, t.b)).toSeq - .flatMap { case (a, xs) => xs.map(x => (a, x)) } - .sorted - - datasetGrouped ?= dataGrouped - } - - check(forAll(prop[Short, Option[Short], Long] _)) - check(forAll(prop[Option[Short], Short, Int] _)) - check(forAll(prop[X1[Option[Short]], Short, Byte] _)) - } - - test("rollupMany('a).agg(sum('b))") { - def prop[A: TypedEncoder : Ordering, Out: TypedEncoder : Numeric] - (data: List[X1[A]])(implicit summable: CatalystSummable[A, Out]): Prop = { - val dataset = TypedDataset.create(data) - val A = dataset.col[A]('a) - - val received = dataset.rollupMany(A).agg(count[X1[A]]()).collect().run().toVector.sortBy(_._2) - val expected = dataset.dataset.rollup("a").count().collect().toVector - .map(row => (Option(row.getAs[A](0)), row.getAs[Long](1))).sortBy(_._2) - - received ?= expected - } - - check(forAll(prop[Int, Long] _)) - } -} \ No newline at end of file diff --git a/dataset/src/test/scala/frameless/ops/SmartProjectTest.scala b/dataset/src/test/scala/frameless/ops/SmartProjectTest.scala deleted file mode 100644 index 233a42aec..000000000 --- a/dataset/src/test/scala/frameless/ops/SmartProjectTest.scala +++ /dev/null @@ -1,59 +0,0 @@ -package frameless -package ops - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import shapeless.test.illTyped - - -case class Foo(i: Int, j: Int, x: String) -case class Bar(i: Int, x: String) -case class InvalidFooProjectionType(i: Int, x: Boolean) -case class InvalidFooProjectionName(i: Int, xerr: String) - -class SmartProjectTest extends TypedDatasetSuite { - // Lazy needed to prevent initialization anterior to the `beforeAll` hook - lazy val dataset = TypedDataset.create(Foo(1, 2, "hi") :: Foo(2, 3, "there") :: Nil) - - test("project Foo to Bar") { - assert(dataset.project[Bar].count().run() === 2) - } - - test("project to InvalidFooProjection should not type check") { - illTyped("dataset.project[InvalidFooProjectionType]") - illTyped("dataset.project[InvalidFooProjectionName]") - } - - test("X4 to X1,X2,X3,X4 projections") { - def prop[A: TypedEncoder, B: TypedEncoder, C: TypedEncoder, D: TypedEncoder](data: Vector[X4[A, B, C, D]]): Prop = { - val dataset = TypedDataset.create(data) - - dataset.project[X4[A, B, C, D]].collect().run().toVector ?= data - dataset.project[X3[A, B, C]].collect().run().toVector ?= data.map(x => X3(x.a, x.b, x.c)) - dataset.project[X2[A, B]].collect().run().toVector ?= data.map(x => X2(x.a, x.b)) - dataset.project[X1[A]].collect().run().toVector ?= data.map(x => X1(x.a)) - } - - check(forAll(prop[Int, String, X1[String], Boolean] _)) - check(forAll(prop[Short, Long, String, Boolean] _)) - check(forAll(prop[Short, (Boolean, Boolean), String, (Int, Int)] _)) - check(forAll(prop[X2[String, Boolean], (Boolean, Boolean), String, Boolean] _)) - check(forAll(prop[X2[String, Boolean], X3[Boolean, Boolean, Long], String, String] _)) - } - - test("X3U to X1,X2,X3 projections") { - def prop[A: TypedEncoder, B: TypedEncoder, C: TypedEncoder](data: Vector[X3U[A, B, C]]): Prop = { - val dataset = TypedDataset.create(data) - - dataset.project[X3[A, B, C]].collect().run().toVector ?= data.map(x => X3(x.a, x.b, x.c)) - dataset.project[X2[A, B]].collect().run().toVector ?= data.map(x => X2(x.a, x.b)) - dataset.project[X1[A]].collect().run().toVector ?= data.map(x => X1(x.a)) - } - - check(forAll(prop[Int, String, X1[String]] _)) - check(forAll(prop[Short, Long, String] _)) - check(forAll(prop[Short, (Boolean, Boolean), String] _)) - check(forAll(prop[X2[String, Boolean], (Boolean, Boolean), String] _)) - check(forAll(prop[X2[String, Boolean], X3[Boolean, Boolean, Long], String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/ops/deserialized/FilterTests.scala b/dataset/src/test/scala/frameless/ops/deserialized/FilterTests.scala deleted file mode 100644 index b53000f09..000000000 --- a/dataset/src/test/scala/frameless/ops/deserialized/FilterTests.scala +++ /dev/null @@ -1,19 +0,0 @@ -package frameless -package ops -package deserialized - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class FilterTests extends TypedDatasetSuite { - test("filter") { - def prop[A: TypedEncoder](filterFunction: A => Boolean, data: Vector[A]): Prop = - TypedDataset.create(data). - deserialized. - filter(filterFunction). - collect().run().toVector =? data.filter(filterFunction) - - check(forAll(prop[Int] _)) - check(forAll(prop[String] _)) - } -} diff --git a/dataset/src/test/scala/frameless/ops/deserialized/FlatMapTests.scala b/dataset/src/test/scala/frameless/ops/deserialized/FlatMapTests.scala deleted file mode 100644 index 7dcd0e4e3..000000000 --- a/dataset/src/test/scala/frameless/ops/deserialized/FlatMapTests.scala +++ /dev/null @@ -1,20 +0,0 @@ -package frameless -package ops -package deserialized - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class FlatMapTests extends TypedDatasetSuite { - test("flatMap") { - def prop[A: TypedEncoder, B: TypedEncoder](flatMapFunction: A => Vector[B], data: Vector[A]): Prop = - TypedDataset.create(data). - deserialized. - flatMap(flatMapFunction). - collect().run().toVector =? data.flatMap(flatMapFunction) - - check(forAll(prop[Int, Int] _)) - check(forAll(prop[Int, String] _)) - check(forAll(prop[String, Int] _)) - } -} diff --git a/dataset/src/test/scala/frameless/ops/deserialized/MapPartitionsTests.scala b/dataset/src/test/scala/frameless/ops/deserialized/MapPartitionsTests.scala deleted file mode 100644 index 06ba04943..000000000 --- a/dataset/src/test/scala/frameless/ops/deserialized/MapPartitionsTests.scala +++ /dev/null @@ -1,22 +0,0 @@ -package frameless -package ops -package deserialized - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class MapPartitionsTests extends TypedDatasetSuite { - test("mapPartitions") { - def prop[A: TypedEncoder, B: TypedEncoder](mapFunction: A => B, data: Vector[A]): Prop = { - val lifted: Iterator[A] => Iterator[B] = _.map(mapFunction) - TypedDataset.create(data). - deserialized. - mapPartitions(lifted). - collect().run().toVector =? data.map(mapFunction) - } - - check(forAll(prop[Int, Int] _)) - check(forAll(prop[Int, String] _)) - check(forAll(prop[String, Int] _)) - } -} diff --git a/dataset/src/test/scala/frameless/ops/deserialized/MapTests.scala b/dataset/src/test/scala/frameless/ops/deserialized/MapTests.scala deleted file mode 100644 index f7cc0fad0..000000000 --- a/dataset/src/test/scala/frameless/ops/deserialized/MapTests.scala +++ /dev/null @@ -1,21 +0,0 @@ -package frameless -package ops -package deserialized - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class MapTests extends TypedDatasetSuite { - test("map") { - def prop[A: TypedEncoder, B: TypedEncoder](mapFunction: A => B, data: Vector[A]): Prop = - TypedDataset.create(data). - deserialized. - map(mapFunction). - collect().run().toVector =? data.map(mapFunction) - - check(forAll(prop[Int, Int] _)) - check(forAll(prop[Int, String] _)) - check(forAll(prop[String, Int] _)) - check(forAll(prop[X1[Int], X1[Int]] _)) - } -} diff --git a/dataset/src/test/scala/frameless/ops/deserialized/ReduceTests.scala b/dataset/src/test/scala/frameless/ops/deserialized/ReduceTests.scala deleted file mode 100644 index 01a074950..000000000 --- a/dataset/src/test/scala/frameless/ops/deserialized/ReduceTests.scala +++ /dev/null @@ -1,23 +0,0 @@ -package frameless -package ops -package deserialized - -import org.scalacheck.Prop -import org.scalacheck.Prop._ - -class ReduceTests extends TypedDatasetSuite { - def prop[A: TypedEncoder](reduceFunction: (A, A) => A)(data: Vector[A]): Prop = - TypedDataset.create(data). - deserialized. - reduceOption(reduceFunction).run() =? data.reduceOption(reduceFunction) - - test("reduce Int") { - check(forAll(prop[Int](_ + _) _)) - check(forAll(prop[Int](_ * _) _)) - } - - test("reduce String") { - def reduce(s1: String, s2: String): String = (s1 ++ s2).sorted - check(forAll(prop[String](reduce) _)) - } -} diff --git a/dataset/src/test/scala/frameless/package.scala b/dataset/src/test/scala/frameless/package.scala deleted file mode 100644 index 13caac86a..000000000 --- a/dataset/src/test/scala/frameless/package.scala +++ /dev/null @@ -1,65 +0,0 @@ -import java.time.format.DateTimeFormatter -import java.time.{LocalDateTime => JavaLocalDateTime} - -import org.scalacheck.{Arbitrary, Gen} - -package object frameless { - /** Fixed decimal point to avoid precision problems specific to Spark */ - implicit val arbBigDecimal: Arbitrary[BigDecimal] = Arbitrary { - for { - x <- Gen.chooseNum(-1000, 1000) - y <- Gen.chooseNum(0, 1000000) - } yield BigDecimal(s"$x.$y") - } - - /** Fixed decimal point to avoid precision problems specific to Spark */ - implicit val arbDouble: Arbitrary[Double] = Arbitrary { - arbBigDecimal.arbitrary.map(_.toDouble) - } - - implicit val arbSqlDate = Arbitrary { - Arbitrary.arbitrary[Int].map(SQLDate) - } - - implicit val arbSqlTimestamp = Arbitrary { - Arbitrary.arbitrary[Long].map(SQLTimestamp) - } - - implicit def arbTuple1[A: Arbitrary] = Arbitrary { - Arbitrary.arbitrary[A].map(Tuple1(_)) - } - - // see issue with scalacheck non serializable Vector: https://github.com/rickynils/scalacheck/issues/315 - implicit def arbVector[A](implicit A: Arbitrary[A]): Arbitrary[Vector[A]] = - Arbitrary(Gen.listOf(A.arbitrary).map(_.toVector)) - - def vectorGen[A: Arbitrary]: Gen[Vector[A]] = arbVector[A].arbitrary - - implicit val arbUdtEncodedClass: Arbitrary[UdtEncodedClass] = Arbitrary { - for { - int <- Arbitrary.arbitrary[Int] - doubles <- Gen.listOf(arbDouble.arbitrary) - } yield new UdtEncodedClass(int, doubles.toArray) - } - - val dateTimeFormatter: DateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm") - - implicit val localDateArb: Arbitrary[JavaLocalDateTime] = Arbitrary { - for { - year <- Gen.chooseNum(1900, 2027) - month <- Gen.chooseNum(1, 12) - dayOfMonth <- Gen.chooseNum(1, 28) - hour <- Gen.chooseNum(1, 23) - minute <- Gen.chooseNum(1, 59) - } yield JavaLocalDateTime.of(year, month, dayOfMonth, hour, minute) - } - - /** LocalDateTime String Generator to test time related Spark functions */ - val dateTimeStringGen: Gen[List[String]] = - for { - listOfDates <- Gen.listOf(localDateArb.arbitrary) - localDate <- listOfDates - } yield localDate.format(dateTimeFormatter) - - val TEST_OUTPUT_DIR = "target/test-output" -} diff --git a/dataset/src/test/scala/frameless/syntax/FramelessSyntaxTests.scala b/dataset/src/test/scala/frameless/syntax/FramelessSyntaxTests.scala deleted file mode 100644 index 5108ed581..000000000 --- a/dataset/src/test/scala/frameless/syntax/FramelessSyntaxTests.scala +++ /dev/null @@ -1,49 +0,0 @@ -package frameless -package syntax - -import org.scalacheck.Prop -import org.scalacheck.Prop._ -import frameless.functions.aggregate._ - -class FramelessSyntaxTests extends TypedDatasetSuite { - // Hide the implicit SparkDelay[Job] on TypedDatasetSuite to avoid ambiguous implicits - override val sparkDelay = null - - def prop[A, B](data: Vector[X2[A, B]])( - implicit ev: TypedEncoder[X2[A, B]] - ): Prop = { - val dataset = TypedDataset.create(data).dataset - val dataframe = dataset.toDF() - - val typedDataset = dataset.typed - val typedDatasetFromDataFrame = dataframe.unsafeTyped[X2[A, B]] - - typedDataset.collect().run().toVector ?= typedDatasetFromDataFrame.collect().run().toVector - } - - test("dataset typed - toTyped") { - def prop[A, B](data: Vector[X2[A, B]])( - implicit ev: TypedEncoder[X2[A, B]] - ): Prop = { - val dataset = session.createDataset(data)(TypedExpressionEncoder(ev)).typed - val dataframe = dataset.toDF() - - dataset.collect().run().toVector ?= dataframe.unsafeTyped[X2[A, B]].collect().run().toVector - } - - check(forAll(prop[Int, String] _)) - check(forAll(prop[X1[Long], String] _)) - } - - test("frameless typed column and aggregate") { - def prop[A: TypedEncoder](a: A, b: A): Prop = { - val d = TypedDataset.create((a, b) :: Nil) - (d.select(d('_1).untyped.typedColumn).collect().run ?= d.select(d('_1)).collect().run).&&( - d.agg(first(d('_1))).collect().run() ?= d.agg(first(d('_1)).untyped.typedAggregate).collect().run() - ) - } - - check(forAll(prop[Int] _)) - check(forAll(prop[X1[Long]] _)) - } -} diff --git a/docs/book/gitbook/fonts/fontawesome/FontAwesome.otf b/docs/book/gitbook/fonts/fontawesome/FontAwesome.otf deleted file mode 100644 index d4de13e832d567ff29c5b4e9561b8c370348cc9c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 124988 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ÐT?>-5aYhU|+1c>&YMpPK5x#-mbV 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'NS^o{z1ZKlHsAybrl=JE7AP369ntV%vB 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 CDx5C> diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.eot b/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.eot deleted file mode 100644 index c7b00d2ba8896fd29de846b19f89fcf0d56ad152..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 76518 zcmZ^JRZtvU(B;hF?rsAN?(R0YJHg%EL-4`f-QC?GxVuBJBzSNO0TKw=Z@2d0uiDz~ z>N?%0@9pZhTXpN4G6MmC{{r-%!vp@O0Rbuhwcr6N8vm31-}!&^|1owS^ws~H{tqAo z$N}5{t^jX<6yPJk2H^Ey%R&Bp#T5O1phx10RX7B{Qt8t9Pl**$n*kadIQ|f;xC*hEUn@g zl*^#1p2$%G{Blbw#9Q*e6@DYa223V18Ij|2&2%cPTvx@iNioUoZ)_KE6Q5=~WJfZ6 z@6#n=xTLp0OA@il+i|so^fL%AHC3|sOKFq@_?XQai){2qkS}rMNBrJi`>xR3*k)Ld4_O*y=YyU9%ULX8Mt|3PGQJ(= zu5_-C{h(64@}ws=y4%mO#^-0|S)8jKTS}tyTCRrQ#rm0C*{&43?>G$we1bThm2RqW zr0DH!n;Ru#`mDbNA2wM$;x!?!a`4fw?Fo~yus67&r1abr>%F0xMWMH?N|{wiNZ+FY zi_q&l)sRzB{O=MeHnz?|4E!7NzLgZx?>wKfMy~TrDUE27f?^!K0pcyz zKgVg~jz3oin*6AlFIecSs@o*bYRurv(wa@E+g$K~!LjVYF|>8*mz38zvT0|~_Z9-@ zFpwD~_2L(!Y&LKA6%F~|!5SJ(mBsg47{V^nyZ*x17OEqVyB;cG?Qs2f_ZtmwuJ*$; zrV4&09S>ZcsCt|3)l&E7&8T&q9=-bJiHDK3=i=dX9doW52uEMp^BA|^$Stu z_bobQ9n=z83Z~xpsct18Hw06@v%p4TXJGmaJEDy&(-v74j^{YHE3)iSLyj)+MAzaq zSB+BK=7$bIV5~T@od+AQJY2H9n&J;sL(S53?(5d<&xHEKF#(AEjDF0n9Jl27)uNRn z=Zqk(EM~|62JY~o@N;`C!oum~!C=AiA|~s%&&Ik>G**GymPqvB`PYqZ;u*QIa+@iL!)+*8P-7K zBA6oelJuQCvn?-o2%~luo8?Xb+G!NZ!7(~d1g2ttZM_#V^1$i{p!Qb*N$?!^+u*hF zV7O^eAoMadrY~~UdHTy?%pjJPqalWC^&_g56Y~m9&?E}nU5>dTmN*NFuSg;4cIJNE z2^EiW?@vNZ#r%d;BJ`>nq>m?N?9aCRC>Eh zlV6Ugn6XebS>cYT-zx{MC|>X&wjrrzRb@<5rN9sBgK3+zcK*f~#(jWcq}V82ZaN6! z3x!(uoZC?rX`+`TZExW@B_Jd`o0*~rUKsn%1&5+DXP_)=VVN6Rw_<%|IIeJXU{K?4 zkvpJ6ee4r5g*02SaFM0f$+GrDNoKlJ$fXCjeyCd_b;&|GDk?G#%7IhpGA~XrsRNoT zSn_IST!)8|RdNz{EK?$GHsh7BU%UL{N}W5${L)#YgMB{m(WaRfq+Ozk=>6yo6i(u{ zf(b&PyZaNLrRm8d?nLwm4RCW`F=y{wXwBU<1oh#53u%tXKBrZtC;g$CQwJ|3=?DCD zerFLv5RFMpC{V>kQ+TCYW{$YVXPdLvhk1i?2BH7*5zlBC=Eg2pWli#0yzi%PDl04! zX&Dv67bLYow-X+mpm<KPeKlSsQEOh60QCqd>_Y|7@=xfK+ngw^ zD9o5yHpH4sx!(oAf3Z~ut%84X+V41Y!;?fEQq#q#+CzZ?=oBqWXmCht%;@0qn-pXU z6&ZLq5MdGq=bNj3NOl3&${$YR2TE&Oh0hG0G2EOV^jo8A(1&RttcnDJzR-h1D#R0}zqpfOicY zzq2MeIM+kW>E-B>q$uKRN2tGiHnK}WNo6&OL>_t; zV1rZISSu}XgE-OkNg2_I@hb}1C?6<}M=_hc-{W8hM8NN;GYL+>#KK0dwCHrBex*Uqk)i)Dqd zU#lhxdi%Txp@ah5XeFm?k7_Yodp z-!k}ec>%eSm}S5O#=xIi$W$Rq_rR|K6>k|OA9X3z72fKks33U6BPZizFb_rTqPa<4 z;wu%~I7|kQWi{Idir_c6&L3<@%aS;uJbxr9td_oX+ztx@{eMop15cA&f zZiD^v=IYY`&qlv@6!HQpzSQKsQBb<*bcP;=jaHWhB2F^2tHq%Km@FhCs z{w($Y`FD&xEyPe52lc_;IpIF-4O|#a2C?nfX+bMIXiumj=O%J`M;E)dMDr)&@>{8C z3)nyTY?5I}>~fhpzYH!hfU7Dx2qW9CttqrJKu+NeWg8bK1ldYw%># z7D=t1FVzX${`^Rx_Q-`n#>5qB3-9K1!*Xpt%P!%+rm=Mzdi@Jv-Mdm(4nCkDi1#eo>L7qH7Xc{4y>=Zeb+Acl}PCs zP|AstTnUNT8LcRAh$XiY&;YtB)*~5^(DOj|p#-~{ESml1S>;0Ihcen0Y@f$jkYvz2 zlW{_1tCm4;RV=Sq@*X zmZs7>+b|O^;)AHk%5D8>7yOUqk}r&jH`_jC_&4rN32Uik1G+>)%Ej{3OW%M*irgZsH)L#PyqEESx$?Bw z(TuNjVL(pLO3PO3^)xyaV&7$hStYhzf%C&8Z|?JwE{VP%s5F$D11$(l8@ST;pbV_A!S5i<$-LImWb|qUoY( zgN-4291V9tZkzizQhq=oU!hNIw6!x{8rpt=AC4u-pxG>Xjeqc9#7@E!m<4@k`?Xc3L zGW*|?jHH~P{52A-aV(Q#{5es%%#G>8C-I`9`^(zDzJgCtLZ*03KIvH6jYvVe~m9=u?k})-Q$0N@CYmQMic;bnk2iJ>Vm8OKV6M&st{n4thcQ|8w z7ghMeK(fX}mM?x8ly1=nqrOKo4P7{=2?9!(bUPhZ*cvf1)bY705uSXn9{deye9Jvelcco2b>1-ZJ}k zFmR^35d_{lz01HTCO8%h4`fhpf)ySyi8hqDTcE(`V1*98k+0cyKPG&K99MoPzY8H%gq4+vdug@>y;9pP%`0(vW5A;I|G%#vZOyK?F z*(Px`vSR3C5JU%x4YH49uOow^77PJrF!ST?xHI~)rAc748p=xY%*3S*Qe3gKQg@pK z49qeg8DkFigyGW>y@|>zttBjSBN$SjknA5 z{#6t?XWP<2GvG6%gog<3*CmZL3)K(*_U>y|O^fpiv&bA|&5RY{7dxl^*^+goJg2=$S8q^swAAT(IoKD~`el<+KI_b*qBp>Acw-d+=MRc4pnDWkV_ zE<-7i*`{-C#UsdI++oxdg-81&2=U7rtwb-4H(MnnJFYlY>jaoE&5kQC`6+!hPo3Y= zbuYPeeaqMB&TtQ&zTJL@@s|{*iX`!P3ws)`oD8McaxEUl1P{3{P07T?i$-JOq)JIq zgRQ`>ilyi5qi{KImy=g-y`U>FT$K`LUty3n>wG0d8N(dMSlmUn^@~JG65S6ak|v%X z>G(IGs&}$r%!vWT1Fm@Eha|%nDG3II4qI;L3SHk4It}(`fHB3W@{Sx7Sz$$dK@)6~ zEMrYY=)_JoWHFc&Jy?*ozRL{n7UPAF_`8^_cxG5<(O0-YRVl5KkW}e?m3H!uh08E4 zcuqC?kiQ;5F5;Uerw;!g2G^M+XHOwy8XWG2d~gLlX^queZie2A3fFhiW7Jlz$8JSG zZRy9o7nLFKFwK`I7JA_bG3~WM_|p1alZ)@~b;MwEwv72`+N5ZECd|CyvsQNlYuxb%h{b6L)Yd4j zJr90~RK>_YG^dJlW#khv(r~oQlosf#7ncRUWMR-q=P~X_f_i#ftf&oHchD~dt_g2A z%SjtjfmS3Prw1h?V=Cl(OvJnPtL6{wwiNU}Qf(Vpe;`IjHGyRu^~q>>+p0uU2lw$x zzX{EKe%A>2&+cpPB+z2=wR_UL_kp=Ktw&-BlZ(aDP&&}Rk9}#xnfy``eTj|gL?Rz; zq5Rvq?aipr>Vy{d#RXNkh3YsJ+s}1u62e(X+T!j+fEOV-9x?NQ(Bk{uiNF@>*)Y@8 zK5|n2^0F4<(YBlU((CA|SGy|XtPpi{lvjSEv=Alv4>(f+IrX7c@bO2+5m;?P0&{fX zxMlz*4#ik)>qCBM1YKaeT#(BXZ9Hf^y#EuDS{@-PIFz=<>Z4a zaIz;#wAF~((i*{OJl~6H8L-h5knI+m*+y3Y)%XfVBDmPk^kz}>xpPodw4Vy%M+srn zfa$)D7(JGeS`AZy<*vyv5lX1n@N`g>rDmI+t#5>9;vOmnHoYtg7Yv}5p7P2yCcRW| zzlUBs$qrUX{3nw|v~_f`>(SgZ`Qa4+Tx1c*l+IzVLbwvDr;P1?$^^UUn!-^}@8Xnm z%fd~=#ZUe-g`*?%S`N1GieL}Lb3o(#AsixR+*z4YGbFTgCQQT#pN*A}NAQIru4^_Q zfGfqz&^(HDzlOh9nRMIRoK5pphXL(PjR^nzg-K|CT`_RkoAZ+(ni{!)1(8u4%#Ssa zc8wPx(53`h2TV}su1f_>Xz;<;0JgxwSB_oVqd;c2Dhi)MZS6Xd44JM+PmT7)IS6ju zrIlm;LReLX))zEtCvMC)>Sk4~wk0I`<4^kT@r8PsP{OfG?uC<28Hf$2oSF$cn$F+o zG1)UiCyfq0t*RJBr7TA_ry@;aEmIS=;e)hq8My+vN-x70gEOKQIsIlGhsWQBCQ^h) zW^)Cxr9?04EB4#0R0d^BS)IEzHm03mqmV4k(Y&49K$a)lfPC7}=$Pb{vS!aGJUz8u{xMruX(ZtQ$Vupj8u)z@a(< zp2!MSE5l0Ph1{$p_A^p{yDwt=0Nu%Y} zF5A7rB?;Mo@{eMwB!WE>5v-n-LtHT*sF}nfV1vaYt2(D26~VK_9Aos3VD(LL+qC( zi;TPVQDWu#gBs})2zSe}9{sPpWd8|~1u=Jd*KFN%4FR`%Whxfr#}0H@%bbCFGAM^X*lh$E+~aZQ zXaUMlg<>2!by_7y1^eYlKdJos+F357hHF;RLdIlp@q3ddq;(KnP;bE{U5|d;1@D=w zV>w)+K=!izn^)|>yBED~ z5=r>LT7R54^@n!+@L61Y(Pw%uI-+@hw1~cV^8&2|fKr~4B(av!>$7 zrC(%zIs2pNRwxiKNbtMy$> zWtRM|L$1SJq!e6jiW^Rw%*s1-A{;-ulF{wX!>~nrl)Gi7bim2+gGp_F6|cOET9-MC zIR7|-f0wiM>m?Oe^MJ*h^Gy_KK5cFLI_lfek(OL?t(NJUzeC$3`DCWWB6oxc?t)4SW$=c1L-XR?gKjR6Z z%?e3HKEkP$k8_FS8)D)1M++Ye?E;^@B2atFY;JXYNvE_jX|4nLe+4`QlIoU#r7-ZN z9w%ORF!TdEE32>(PP*9f!4+1ypjF8X34VRdCG>HWCXSZ+4n3H)>6&dLmDWrcEa$2m$ z<{P|tfdhbDou2!+3#eDom0vm@rRTzdaNf?nr%1`}2fuAx?vw1XxNjyCVu`X4lfCPO zQw{A&4#6$$$uk_U2))K_Xp5H)Ynj;M%OG+#5wovXa41ut|FriC zZ5?nF#JuH|{ni@Rb1?Wt0L4ckFaEV!VW!ox)2vWV@m0ortHgG<(|&aztcf*qm+?!L z)zAGm9oxG%PF6M%JF9lvlniIsGlaGwZ)XwlR?d=41aBnzLpe1FoItFRR;`$mDLx}A zXs(tnZMYsu$8goUuhiJ6uK@{%@GO~1CH!K6;^W6x_<&#;VzU=8n&L{Tu=AvTmmg1Y z%U|1*!pwm5>I!81otTNe4X4)T`r@h)MLmIfania|o4YiMP_|=}*4 zm_pWIwxkEH#`m|aw5Oj2cV-uB#SJ`daQMf&=~kRF@3xsN+UR(DDz5Yk8lDcaoW=`$ z;qNA4Vl#=JGw=*2{Zi7KlpC7JONZ1XD_bq&cHo~j$03Xtp1(JuD@k*#UgfxYMp_f1 zHeEc9Kcgq&|B5(vDZy+(Etf2hJ>k|_^m5d}rVF#m0M#V`Q9`v_-A*{>_qn*375dUg z20xPEwUamwFwVaNtLQZ3gYac3D)sy^c<-eomp&)JqaRT_aA6r=N2r6`KOM+GMJ=uR zJJSx}{}`IzagvLgClXz7Op`%JxJVWdnAdVtZ1L!MfIpFd5$mbn)VtpZ2Dq#c};nB58w+tL1@BkvVm+h71i)f_rIG$a3$o)nd2gZCgqZg~DGttbCOjwn?T1fRRA~iA+N6zr-;& z7UpcL;{pJJf)iyuS*g7~6!ti&x@hgZ#xgHB8ZB0#Wgu+Hz!hHcArgMW)f)z%?s16( zJeG`Z`(w!uZJjB~*T>P26oGK0$6Ra+4CRgGJkwbG9@u7+)h--#OMaS^94%|>j;>R~ zT%qfgW0)@wi&e~`^<*MZCoDx~+mYuARSCYEm>;`|buUuX)z=r)Q}WwRB&Vel;HOqY zt?1$U*XyTspA5UDMs;VDIKkBMCB~1`(9)wALGvaW59!Wb3>nh!}Np-waLby1tarvXP0A|3ysMqsnTY z7IT-5SgV|NZN3<9`r9|e9fK*l^~72~4KML@f2-=7XWD<6>M0GD5j6}OvWt#l46g@+ zBn=-(Fs@xS?n)J$Xr>RwZ_#oKk$->E5KPBlHq*q3&L}J6YBw6pbza1XN073{97~#q zTReDJZ>6J@;i^yfR}+Lp_`&iT@`z?ozx07)PYkFJXy~x!aMN}S`gwL~_GHQp#>HGX zc~A1Bx|bR2FLSL3hpVg$;3TbFS7q&}#y9$O_!03nh!J87!{4e)7zFtHXwl@hB7Ltnv=C{#bIp5A)l^z}mW$@fR7r0bAlUmCVRMlibs5x5Fq4U26 zSFZIg+>*5IGz!0zBUOpKJ^_PQ{#c44>MBlmvZ+1}#mCe>UnZt2iU;`b4=Ks`%8=u9 z$TmiTS2eHRY>QENc*e&d zSDHMkA*D}>uf!<*^B@wSh{4gG$_){w<$pQR|-hgLw&6qP`8Ot%3y;b<*UB2J;84$BC@z( z0JW2)PBTCCKjX|mU582DgEFE<$JPnr*zT}0k1YqgH^4CNNRbg-kp)`adn6aOvc~Tn zZ**XdG-;klXk22VA)~sxk zl~ViCm}zxxbQj#Q`nC&yi@#^Z4_kTje7HHX#Z9r)ohqOEbpwy|I29~GU6A64V_oa- zLeTsWwy=D=%p;5cn~o;lcCmBai2-3vZ%ow2_$y+$xZE9a9NyBP=T&sy)Ht&2m;fC*D$x5eeA zk|-3we#iLoM>`ak;r{MPxn_C^#s}X4GPjq<$1sEism9i!lz}3?-rmuB8BWatzqo_u zwojq@6^6W+?#sB(9A-t6S&x7YT$vmtWaS;So$z-~JKO2G?-jkjqh>t+a_WEt+UFN2 zX@i+V!X=T>N6gbBpMIqWgnj>PP)q5?JS)9!FEc|KN!IE{ij84)nbj-Fp?IQ>I3o*tsg#=d zduJ2{dC>k_+kw1CyPEmT_g$u?`dcCuf3qeu{4TTVg=R*}j9DycOo`bl2sfcvQuTPx z?po`60aA%Z<-w~g69NG@P}incHlH&rU9IM^nT~4%9$7g^@?rS!(MqgRJAhv=01gvcsK9^v8!{G&A@>6m%IkksPO8n*BL%HvD+ z#1N7N*nuKngpyM}cTkz$mIui*s@j$rcOKW;h8LAWl|eNQQ+A}^V=lrg45+OX9s2t8 zAYKBQRcHvp{l_zqn{q94ZJm+Q9>$`T9V9WCTy`4=i*k~7emc>orp&GxoJ`xJ@4OpD z*Rn@(dYy_9^u3@7bxh7W)JC(!q&=JLC9+=wxj+;eROQ*+{T{CIb;eL{Yt^8Zu`zc< z6ptq)CN(2r-zo;gjze{^RT84YICcamlGLO+%Gl7MtQj`-vwL7&?an*?+sn~_ zt`vD-=Lpc(ZfZb7+HU?4^Om-*0Q>zK1gOU&R;H*WI9<0)Hmhh?85x07-0Ho$td7vV z(N&g`doL6KXLkkXfHP59hvX-7jiW1H`QI3|tb3JWmwKYdXIJ_(}J1UBkge6&iZ6@DsuDW^%3T)knHF{CVE z%`NIrU76*s&S;^Ux)-wRNNKGyW0@S~o%L&f=^6HwcK7Zq?`uX^n3EUiTSg#O631ZK zhePX`V<*B=tqBB-E2jueWZP5*2ZYJqU~6 zBthp-#yiU7$bn-vlO{XhsQf+=_^5EWB&PL>(qQ{5(}N~^_l1F9M0crNEp74zU!CK* z5+0OcMd~LgQO6}Z{I{s$OauK+_pEI+*`E%*Qhn)cU&#&3uVg2pro5A_Js>f_SFWf| zcNd_qX(H_|;#0s#1?X5;oeHPuVm^XdAWkDlU6o`E4+fXA(tI=sV*EvvJr^BUTjg;L zRc>*Ov4>gW1(e#kqZJaVa=D$r3@~-;gkt_7CDSb-BI5{CVU1xd=d>b)(K?zRSwgi; z`Ov)Xqi6P9&?ZzD^ZS5DaAU6Ejbx1W#ue3tB)PPgx}pxCWbnu{7TB zT5)79g_Sw+<3?74^>ArZ=-u%^Ox&LRnZA_Wv>%$&R=L83HBq0j6kvSW#Y`0dvfYAc zwucJsR2@!xnRV+ksY}=3*80R548sDS$t9ZDG;8|8%B_QsRz7bpV@d6C#Pe>TJ17NV zPS3X<+Dsc$rV!d}7La2q#0e-;nkB=jzDzIWm*iXVnd2wUjl266^DEuOIvAzaYfAwS zMT;_^d3Wa)Pky!*tkS+&(k!z>7*v2O5{HaDz>TOYWc__NV^L^s&?A|2sO6nge%=ZY z0|*A1n5qp&3XBKw*I0a1{O6+qroT(KmtZX$cGrM3Cg$8Q|BoVSrxnyM{uJ1TS$$|R;P07KaK|`q;h~KgahRhdM`*O!*o`&YmZ&TQ zqx;X%9TI=&7eKZ$4H7tc@D6&*;=-7Vy_b6lfPYR&;r=jkYmHTbNnt8oB5s9!;m~48 z$T{?_x9Q>K5M&bdQD-N^4`e&2_iG-nl?uBCnu2-7t7;W(f&r*Faq}WFqxK}fGayft z)2xxKu59kD-q$3x{4Id}%C@T?h4XV#XZE-RCr=F1}H^Y)jtRPPxHA0Uo&r+>O z0g7T-m&;kfeyy1b(v1=qefXt98L}400}2#KTYOa9QP!$zVVa@l5Y3dB@kZoAmfX;R zV>upE4WL$a_v6;N{@Q_c2W1j3eW!$A88^N)*fdVT@zQkh3 zD*h+>;mydfvTvZwH$P2qyUz32NAK$g^se~NX6Bn};&&J>)-!r#zd!ES@T-VVcuNTs z#3gC0WlM5X0whJV-AePkU&L%;{d8M7f7)W0Ay~S2(YrCc*DcM5v;mz_CebG?Xs89k zw05F#M-qY;kE59naU7lOpeuO=QLnK{-i<-p@Ay#T@|5$}Fj$R~H?NH10z49&!d6^B z7n)z_l=cXO)^NZr8Dw;KfXn!?50wcGz&ra9b@*Wu5y+`MMSa;Q)WzaIzhKO+lgsA< ztmylLs$4O^cLMW=H_M;8?{_5F@j7rXnqGDvw!>?tPW}heo1^k*f(ZXkR-y z&s+%>H#vA}82FR_f(62_G4ts@x96YP>D3#@P#f~cVJ~wNclR8P|^=TnxtH0 z!SXNPWDbP}(x}4cl|*h>{AkXKosER(+hLI#U!h1gw-EpNa#Cs03vcWxb6)|ux6snx z?6YA;_4JOl@3*v+FocRkjV?s`#Gq{Lt)Am#mh`=sS>v82BBS)aD=Pp z56y9Gct{k#+V=4#Ai|?q1q~N!V(!DfRu2XB3#SdAvc@ILjAo9ZvL44{LX`_S{@}91 zfLN7!wAQV06aYK5yr|AwF1hQ8*Ewn1{%4(E%WPGXFcIMpF`Z8vXejimaC6#84x0ML*)wNq|d{d@v1!m zby#$pb&l6P)aA0emeBo4ba?37pl?(#?p1N&$x@}a$)IVs@2S(xN+5tI-GG8^&y&&n z&A+pD{IhPB&D{;zMrD{lhNURjPETasrX4R1uGuLkEib=3f#TY9&6! ze2&2$z}3R(a8k&G6q^`8kSig0ykqA9hf^5A)l7B5PH;+|14qC6xgA6)^odb+ z!cfr{LF%gp?8;5^x?{MkYt0&vvASrI^3q}VHY7l`GoV_y#EF83~NB0Ubl)E6~1Q=JFOq0Z6T44Kw#3WLy5tGrJ*^95D?mxR(m zE0S>-2bJ0m-;E(Wn5@XSWW!OlRRWDCRcLhp1%O$TK<9~AWI4mt>f^K$i8Mmm>e&-{ zE=KIM7Jz!v>+P#6pfhH~uEF9u)Qb`C_Z6W#$yrOb z??i}Sau93jat+Q&t}qG42(E7Aes*_2m#Z7i#}&C(4Pd4G(7vGts2nLsO-cK05Z@pC zEfQs7vPJeA(b|qp_uq{$D8QCtCHB!Y=~=D46fj)#H5Z^gh*DREuh2?`K+vw+R>}C$ zR%n>vs4tlj)fF;u+q2R6IKG(`&tV5&(~*NG%!iXnPdh6ACF@j{+M~gq0^vTifT`DzkCqV)_^*;_t z?%X=Gw?Q~DzH^#b`oxYO=scL@~qpi;O&x;(<7Sj z_1rYs5pajTzTPm~H$)6JQxH5^NRQWJA;k&&xH03VVec6yQgAMZly zFbO9!{1N&0s`b>i!5KWMewhlKV}y|>tMMcbvWb(=HnL1Z(po8oTFR#YKc9{)O=9NY zD1awJo$R7)(V-0=pp!o&o`%NU4wGJx=ltqD?$!2{&Du^P69~sB)Jk=M&=N|3Oi*c! zY`Ot%&<(AGrt5X*p|&NiGTw$O-uG-Z&BD*c7!vO1?-c_7C1-ePl&M^NZ z@sV%Dh(*wq1~%oo%N|$$&$;`_rnx_Pu0Q&7GkswF1nI~y>t#ElK(6*9#$uK>sej#e z<`2ZEq^EAM&sdme`&eIKG2d+o2>ulmh#=la54V{Ho+GpZO9 zaAzHB%$GQuL;t#}c3v)y8h(F-P?ezCBiW#90Ou^qX_yY*u8HiYdx47YA~HkP9NOB+JY2 ztxPT;X?H>ES(<}W0z3Xp=1|T(b;$`f9{fb?bpVf`q8S?;`D3jgk9cQ?-~G#k_>ad0 zpaR9ya?fYn05QYxp_78F^0)M)k+9wMYdzg+x=fJe_~J2pEz75!`W!*iTY7&~^ODkB zSr`xUC;-j2#MtCVK5d3`(%M@u^2iRkvJ$Z!3eq3D99duVFa!VKM4 zTtt=2VgVw8tiWbn9u{zx=3$P<6mxLF8zWLpDsy|F&xIs$s=&&=(%sD1gsB3mPwW@? z0W<{G-)JN;CjPK6df$c(Sno(3zZ8g9i}vLm4ud~Gpvqr&eim_#c+S8wt-QW8+a#F> zE&OC*u%p6Gsj=$Q=*uT3E;`ZCQGL?LNPHJ+G}k5M@?k8^>XZH_=rT4(CdTLIGhNLQ z`~-J{`z=&^-b5=(vC}&jk5p8o?SLAj%@@4)#HJNNLQk=Lch<&^g@FC%PDAa6JP|J^ zSZMpiOprq3QzV+Nx(K88S5XNIS?oK40@+?U*t zzI?Bk#)1L50E!au_7e16j8_urA2D4l`QOGA#^hP-YMSlKH6RJY3o91sPXDkB;vm(v zTG~b~JW^K5r4U7qd{iTKBS-~fn5kcl_zZpbdHA>h$RPM zhAGVabHg-B!$YQbocLrTH1fzsPpgbh&J#}cVkrmM>PiCf&0`32@81ZEV{z705cex9 zo8y#4k#|Rh%$^?I(qt~3#xpY z`ga*dx}*Qe=m0eTrFx!M*~5bE1b!2cDV5MEvukT}Kukems{D+PZZ1$lqBL{qoQg{v zSdoWv+CjVvCTUjtN)`q(b@W1h)6EKzTep)p+Jsz1?v;PPNn0a!Cz|jd$e}8GPfQ`v z!deRYNY{)rR_U@y_cuXj8w>?YZv>h~hx1p*m@XbVW3&v=+4kM0@{^DGESiWsG}?#a zj+!6QJoxL2G70jbu(DNe=(;V8*r5iVSEm`Vmo|>yhpEL?_})!wX;4do?(->kenzh| zEglV5Vg9fgOSn#X@Dj#m-iOJ!))PzWU?X5(N-s2-T$*wl=2m=>ViWiw(fzYb^jy&# zRP*+blhO{`KD~w!(Bk^jyy3ziqZr8wZCWN($i?z_)3&hV6E6HC76k;S?AKK2)? zC^`K=9B-KOdI~i-a`&uJi<`uWx_G~Xi5}{8{9ybvoWz=fgq9no*8Ffqb9`)SL}u*I zVHBft;EZjVy$=KocSUB+SSuoK9eH;G6ZHbV+v{DLD>ksJ+oDEv%^GTl^%!?m&7#%$v&m{2N~mV3zVocl-e zV$E)08eyW|u{O@|LNL4Pedz3z;q|e8$opdQJ>bM850y4<3a4$@UU;i@Z^2okY9_X9 zInWaI#=Ds1KXsqr*t{U&L&)}d(Ganur`4Et)Gk^}a@5fe?SEHtRIR|K@S`?(3dR;G zQ85L%VQXlZGd3PeRfD^rql`8>*#k8tMD?7JIFlR5&;G=RQvE5bB`R~AQ&zey&)M8N zEmm^+TeHNfcGz}HDa}l81`7#$k8*O&WVdxLJXe|@VX(6D^?z@B?u;uJ(olj{z7>su zC#}J{XiIxi)Ox>Qq_!s&`LXCxOJJT0UX{!{smJz^cpN~UvmoD*uOL9MJ&X>=S@LO4 zF}!``sYN>GQOKYinj)}6efP7(#vq?rzR$0z(tvmmivrvTCX*)a50Puil%3zZx9 zC}pf?tOP5ly5v^a`zReScF^$gfDS>Vh|snQuCA4q$_But2oqTIdM9uYK(A=}%kIqA zWU6Ym^qE!W#saA+-t2HcC>Z%ILxNZ?of8*M(756UfpyxbWXKf_xmr`}@Q!ues=l3i zd`2dIZf*su00o8FDgyHR3i_#~yam8aa+NGS-_g|%*;QsEbH^vRD!% z8azp}Uq^dJIqoBJP!RN8;(y^m{qks;&CwDzBpzX~DvzYDP~1Oh76FOElR5{Rrb!3w-4fvF@7eof?Fh#GzcMlmaC^$4%N3nv%yb*Qre+m zOpR57XcKI+1X9nd=poXR_~gI}VA7pWp=PGAuhu0X$y59FM|{~NUQYzm=*GF?!fnp2 z)((Y}BQ#t}Mtf(E2%7>oXDMDMFHpLfX22S99VnI|a5XwQ_aN}Je)*kZPo64HYEmrG z8u3Yp&HG1$G*gi|{SXY|Nvp>tj>h5*JexR(ezb^gl$FISb|d>ZNkR&xFi)}Nm;;71 z;Gmf1O%R{V;{Rc4Qb*#b->^1(NgTwg(}FhHFlHL?*S!l;XZK~<=x9CK?kCV58c@H|y(ETCdqd9|^8 z1u7`r7(XTk`dPjJ2G)Ug6;-F1{b+vym)!KCR6yX(G5J%!ouIwIFqzVV*S9h2!0a>0;YjB?@cm!8IXljZR!dmD2>tN<@_GK`1>0Z_Q;vNx4u}=)CBN ziwPa99Dh<=X;EOYJ!Hf|TV!XGVFSYz&fzIB(J%*&ihBz*7J32D!+iPn$st7oSYakZ zEO5d;MuUf7sgad}f&i*^2jjWVvLHSH4BIzb|b0A3fI07mknVqp&{Ax0Z&&JY&E#eg&ErHdwv zw>B(=v+Uy9Vco6p)c{gO280b~lyn=KI5k0`%M>1JO>uuuzhyVoy9Q-G+`ptjp>h zo44w;?o6>{>g87d0KaU9htDJdlXSI=ql_e5u-#E`y}U{Y@nzMmFov+-!qy=PBi*~_ znq!TaZ~u6VKmj$~mY3aP`UuT~_JEfWCZba;;EVv;-BYi=%G9O{U6u;pA;~@GLO3UP zgo>XDyFd=*Z;)kvCP&hf36EFSE^e)O8Pk!OUzl*Lx8q^o`_ufSMG;rAfHJP{7*H%} zv_t~gAOM_70j?r9>BaQPPp8Hn)2x$82DKGSe@6Lwj8t7@<5__U66x>?N}IpQWTHIQ z`cF&b>xtF0J2*MjML45y^-WQ)!31em$JWst0kS>&*smKjE9{jdr;I2ZP!3k_;LFtQGLQx}6bWvynfH6MW#_8+lh z1rrb}PhtBCCvbcS#Km0|4$Yh3iZOdzlg;714m5YeQC9p*wlGXjd?*z1T?4UJ!Tc19 zb{W(8&?&X?6kPhof$EA8-NI!~H*hlY7%eipd53rjJ$;7px-5AOmzNcVOgbDEL)+p7 z!x(0*t|Ee>4@N+SR&BxX_G++9QVv8B5e`-s7AOD|Ee5sgBE%-1r7Vo2Qp&(4H$J<- zFF&E>-P4#&+jM{|0FS{4a!jD*ZjP128{+qHvoJ1ZL*y3};TacT)BZ)TsSelUdF4N< z?F)(+%(bq8ajUARy9&)QFbQ#C;ax=@tIEMf*9}6^VQNakjPbcsA z=%~tnDTyuWJk-;v`4J$Ru*|kBI@zoTWG%eVf4#j|l-~n1P$QsSL;$8A!9S%=!`9H} za0x5~2cgdTg9$r5AsStY7$y80DT-dWEgaF-%_mp6C$eCazB$%4D^`17Dy5hVv=d=aDRFjsnBzTD*sju)@q~_|wDb@)WxsaENW1K4>-w zJ}KoiwT13~^-$|Xq{0U~qoGvhC-Y{5Gs*zp(}ZX)NGBG}>dU%*(S|M-3P3F!9fyG_ z*z)9WG#e4i>9Or1{=|WSC4|qyXZMp;cCIT->1WBV=0DG|7PHTAb5jAeYH?bytEr-Z zat#7~;Xw#LH7GvL0|p3AFqX_Bz)pPwq@BjGX5jtGfWRO!V)=PRZG0Ye#} zUKE|PqCwaV2hYnccj*E^itgl5@Y1EWxGr)oL-iWhAclQFic#`DA@qeyc8R$dS$>c^ zq-x=D-j|HioIsBZMqFV!EclL?*<`5~ZDE=6F$zhx{5s;*c0@EaMBpN(ie;p1h#IIW z*SnSo0kVxC0?Sy)RPh!83B?BT(N}aC2#XC-sQx2MLPSY7Ye0&5jZU(gfiHMVmse9eny}OWE|_ss`HBl+m3WYr zgNf-bi)Zw8+Y&8s0d?7ao717BRtpn#y2BS7B-DdJbG8m5!toU}12^UvAP~Y4C@oBt z_VKw-4cI_nE)RK}Zan<9HK)en$NeugoFm$U4`-4B1ya|*xMd>6J87B|5d@+7`LESV z^sk_GpIYwFB3}gn1!EwRuFBoF7*7HSD^h`BvFw6TxX@rO66y?DWUtl(oK6U_#(fv* z<}ZntO77Prb--aU{TE1kK@!}ulUcyF3u@6{cheLxLa%MsfsF8e2Ucj~OJ=?n%ThT( z@WneCLW~cHAwy>~_U)jeR6`SBqX0xMC!8b+k>%m9xbQ-PK1Di5@(V(B9{FUdkdgBU zR6ww0h*M~bKq8C**wwK8QvL2L->5Q=BO4((Ig*SGqL51*^7&6hJfEaeFh|&$$$*bB zn#J28P-jL65un5eHG|Ml>GTChl-6hrPS*=AY)dfdkb=S{L6I%;2p`RFN-ZbymsW~n zpg4pZ2zwbmgz_{S7Cuu738@d`qHYkW62j9$^l>6AViD%Sw*T$O!qb~@GRw5v!z(^4~ zDO+V>5DQY3ZE(c(d_TTcfGVZwOHI{fbS(ou7UOymr_hcK>~3$hqA zsJlPVTAVE+lzT?|$^tW>T*fQPg6DXPJ_C$^%{3HSHRT&@4V?lyizRW*bS}qLA!zwo zb=>kits?_nscSE9;;`<=Gv(>uRE26gV7|L+69YEbcUnxP9`XU`-c#Q zy}>AzqxiGcwAC61DO)7YRgxJsy~C$M5PO73!il3ZkPaxY`$^n+V>;qxg>{vTc~lj} zU{rCL6!&94Vc5zkvf`4z`A;M>VE7HA;zWo(*7=*K?t9_lm|lR9N04|fIxsq+T{IN| zf&MLru8%{Ch%C|87E1`O_n>XtipEGZ8H(~24)8*gmD_3O{wf>7DdLqm)$(Lu_2~vF zYHvBColR*ebHraLdAz-*bZS@l$#lkLMWEg1pJ2K^weak6X2;+rlDkIEvsOj*` ztPGBiwg^tv2(%6iTp`=;pQX{iqKu+^0i` zl{ za_YycuGTRZAz?+i3obzpw2O3ATAI#)eLfBH^$W5pzhYC4gkA_qnI;~^fe{ife|57; zYzKn7nz()A$(=HV!Xhm}u;7q63P8d9qeaEywQSv#Ie1Iq zk|Or<2`8;U#0x|vYZ+n48YbdRYb=@$L_?POJFFrpC^{ebT+YK#5}>zva-F6vbTCqU z3u5p#4k)$M%qb==Q~*NK7{G4sFkE2{-P>?jbh0ENcQ>RV>O_K&OCCTI0<2_VPK}Jh zS`r74775h?Bg9V<6^X(Fb|k@|qhJ`MB1S3{E?XfrnVW%}C++Xf;mh)&(B<51J|G(u zM3B(E6j+@*|2BxxERh(i?3_glJ~R2tc%*He2*r8&2SM3*Yd{K<5+Nv8wbbXrD{}PG^a|s5;iDU(;+#tQ&&&Ej+7j_~{ zpab$i28w|oY=yd!{K{?RM&)sESTUv+MBNS=5(QB65LN3-!Q&NuqCj?2TQC&tv(j80 z+%kYd$ovu(s4$5p?vnva4StrRQ3l7sML2`t7Z@=DaiEC~1wxw-*dI=EN6q#@NmD3Z zaThw^U20ho?SLzwCpT}1ZxDde%oZnTS!4@3>ca}0U2zNKqh&LLT0lrx)-Q)XUY9xlM%4alfrTq9*-7VEvfT+ zQQ^WwH&Flh7R7IPcMK~3Ubc|3Tz>O*1}#iAwQEcF+K>I2|Srnufix`i;$h= z278e4xamMjL`qFLB}M{Myqi|ZnvYBrn0Y2=wY&)pihxe*hL!=s%LQgQ2ne>KQ0oVd z0Gg-ZqjMzU`cs9F>LW5w{Km2!6gmbV4oaO0n{4JVI8*0bjd=nBem_f3jvRXclU>k7 z4pY({B@+*jmu)SP_Nn6}ofJ|Zf7~KrEaFklgcT&DEHsMpGfQ15d?D;w7iqYngT85I z{5eEq)X*%?!?T62FLphO%ZNZa&Rc1mR6GBQdxT3{6Jv9Mv-VQ>)XzjX~S2@JT8;#0jz2yDszST58KF5u+FhS97` z7ma&gJyXC$29ei}lQaHkVsW~D@Z6^4Vvg`dbFdR{w zaUR@M$C7w0T!+f4@{H$!pvZ`nMf%Niyxs?P5^iEW0BBYA8)gTIaPlZ8WsuE`N$*KH zFoeFF^6m|yHszEC>acYgZULelP%qn}K)kolyJ^4~Ll@E#?$td66J(mpdx0XwBP|tE>8I`D1{ArPL$il`H7v6fQn>uulX0AP!Ih9Y=*tAE*k1{ zCGhzv*%pKExmPAvle^ggwl)apq5&F~?U^308=hL);s3-74Is|y3I>6+E*nxHJ}cB4 zSJLpI&ue-h`mt$yoo!kg0A-v@c0(D9+!gu|2t|zFZF}PcVZKZNd>Av%uO~Y;h__)l zAc+a|{ys!i~p#5)`C_;Vp({i>(aS zbV@0)UfEv)R)DR&V00)%mOS#dRb@d}TY``Y9fI2;Qnd{!@yIO|w3Qg`EauL};)SEp zEg4qjVK04QbJ#Qk*c2?0x30v;W65clhOu7rsbm94Yi_+1VDK~(1vFgieL(b=tPE`5 zxaMOeAY$m6F}!%L8-Wp`8A;UcfRiB)qAs;dwdQDQZ`7hXF4ATCi7|j06lyY8ti}4~ zso(Js72tm6=3K_*d@`t} za{`FT;rZ}Fzw&ardlq&lkfQiACE}Rb%CUneo)Ew$i^n_wfC)XxR+R0NVBIPD0HV^8 zpqg-xgM`EyWA8x*qdu$_j1|Rz>>OEAlp8*aE#?c*2?$LOQ35htvM%x6v~Cj?Ia`=S z827upiUD#9Fe*-fZ4D)SSf1WzH_{$`v>Sz_*vsdNqw z^Qen9qhv&mU-s?p!nJCMCpQEOFM`0r#6Nr%2Ttav$@VMCZOE3Vu4}P37J+-mBL-+c;G8|42x>NL3`Y@M9hV9hD$y=X2~N!7u=N-Qe9&ejSO3kJl$t;mp~Kt zGHBgyP?1-qOmR5XBSxZuW^@Wd2oz`OK91B-R8 zkxcBe1{s@}035)UU^v{N8bfuT#Vjoa$r1`1KG*la9GkXRy3?vzBPqrbXz42CXWTs<##xGy6XdzUMzlenhIWCP=ZfU3x3kI4Ir zVriKO%Lj!jB&uC7qypuBDRfkVW=5Ht+?|1swi$Ify+~#R?Mg`mWy=0E z24+m-47sWxo1uC>57?Z4eOLfpw}LVfbUXkk6+4J&!57o%fd{;-WP+y-ON^yV!T~vw z9t$w<=uQJX3bqI))jnifF;J#uSt7$S%SeYjH6$eRndvsNp)$f^)9BtUWw4=;Nwaw9 zdrp35%RvCaZj`)3Pr##Xw%TbU3<(yWm=T1esa=isE^)k+Ig(f#K3m}4azEnWgp{o? zpDhicM>^D&GSR?-a6~+G-0Co3E;yn3o6d~@AYYGtc z@KG9NspyGX%WZHKHxbuAFWdlNyGEtbXV=b)0 z#r(@F&Pu1uD;fED#{$tI+D;&4(Sl*6_+HzU>F$b#-0Iqu&DS<$J()e7Owy#okQNpI z&|qKGk*iYm1`f_h1fik5I#5wE*F;(_2oKL{8ibgR5FZ~b9|_QbVu}$I^7b$nwm=5I zWB9YTcrT=gIzu(qh6onU3y8JZM{ZV*p~CX|01XY53= zb1yVdB)3+?FGTqem7QQbK(NG@#E_0a=NOb9Igx`{~Xe8N_BW(-RdZsOwG?8SWVW)5ioDaBGGhj8} zGeWvScYqEnt;*a1Drzn8vM;n&<%ufrg`W${UD$3UoiO+(f-0Ce?F@xzYiLNdm!UXT zhPvp7VnqP{igU{^7nj}9HZdtainm+f0e~gMlavNlvy!yE$b@Uj_M}tur5I?)P@OGb zZ7;QS6ep)#@Gnwx5RMGijzxdbLxah~p!`I+hAz7&t1bsH zH!{kw>6yDdLa z)WNxw)?mzm4T3ffui_Ng#Ttjh4--dqa@0q%9N}kG3d_ry9V%7YnD9g-EGBFeTE%kzu1PNKRh;5!J-Y*e>c@Bhbp|PdG{36+lFdLUHqbLIC4!qU z>d^OgH^F7GwYpq9EDk{+E{-7w$tC^6`}0{1ur@y9#@u;QH|6c1M;djPaCj0UA+5l$ zgU~usjSW*kTOJ*T+fx#^c=H1B6v?I7U$AP{nR!U17|&-PNJuVN3(@X2YQz)ohwYxt zAQHf9D82q=lIR!sWkw)pV5(Q9tr*)9f86Qv}Qfa#B^7m8ltY%M&s zu-}`6Ms)(M^%yX~Zgs_AqzN0oM9kB1i1%n)dAxaUI)$oR616uqxKp>G#DfBx`N2sI z2Vjw9dd*;f1GXrNg{D|%A^s=+SfGt&JNKQ66`zA9SIU#fOpshIrZ(2aV2HHiFo8fZ zbm3n?I0kF+kMb`S3wWwRCYJMH+GK@3xv($h@7Zx86XHpO5-o_8i5!3|)u+fA3`BCd z8feA!AR6Vc9j;j9XJEi8nCR>z+9%gG!^_cO{YKLqHCN|s?vor-tm5GG0$e4t(r8*u_CFKhweh}19V24;x??DQaM1UBL{Gk}jWGGn1;?NL z6`ThLooCqdGU^{WT)piy!&v2|)XD*%ie3N&1F2aZ&h|pRP2gUXV+RB@AcZ53`JYN1 z4+Akpwo3CqJx&31AZ3EP&xRSD_-}v<^f*CPIE^*?@JYMKus|dL5E}i{Y5LDziHKR7 zU?5L~&>=((g__SXBc)SmzB0f<5jNlD+rDd#xlFq=z?|q^bvk3Mu%Lwd_&)7KTrxVq zS{^NxNmdqAifA?x$8S<2e5p!|^_abY$KJ*Mj##+kiu^gu(GhJG`f~@0ErzZj^1;Oj zY@U9sxu$?;--I}h_!MY^x6Xucab^nu==L;SLV}lz#Kl;EF^`H5CT0sH6&PO?*fBH^ zZVXXTku5%LdG1k&jFEEE3az+|x<6q$uZ*sLnxM_k>EXg6<_Lio+SCr3@;lKlrK zf~)JKw3s92!`aA=O&WxF}CvMA~mU{UTF4*T3zr@%@j?FWVf{vQd|gR$TuCDf>o zbf^y!jF`Mo9;3MoE>4|EBY>H#7gy9pzv5UG&L*aEL9FhzEfN&6z zq-q|!5Udh=9PExVuqo}vXqnL8W<6-sLrxG3@{1G@ig6s!Yh>#d9TEhQ+QfjsNq`va zZd^3Lg%*JrRE@7{N>$;IX#O!19?iA@MNFY;%NVcd84>(R>p`_qxVve;xAp#0-G2|@%nMr`(JAbof zx4%(oZ3855zl9w%$|2WodQm%67&Zg~V{`b?U^1tJCxrbvl)I!lM1q_!woy{Pq$?W9 zgxe>O=Q1*j$Mx$F>}R_3U02QIB)5?be2xViCwQmFHSVBdp?}+7p`>p}i$Rz*WV~^9 z{>nxBAp8;yu*|$VyfKaN5zb?8YX~=IZ z-4%9~acKW`ft&SYhX4wj*epuwKGEXgmCyeLfe`*>-TgkX?CcB{V7is-|C*s_z(8j_8&>s*>Qb`KsAxw)43(q7$nAWWztby(uG?d4&+W%#=SkTb`=$?F- zM(E)Nm9l-?BP^7l-7+SQ3YbhH{=v|wNOtoK94Z_6Sw$pMxBoXo35l>%IS7*oOn*Nt zG`LMKEQ&0S2O;>M**Xb)FYJW*7ibcpOHd)x;hFHk^R~`+8&ObOqA=^kSgfn+t}GjV zrNkCOmhga0(&qbPo%*AjG}K?Jh*}6MlA6)IGvHBZ%TVC+2nz@Z7iA|0<@rQFaMvxS z?pKy9fd%FO)(aTsOgl5g@IJS0SKlC=4z7Yxt$tDODjWAt8$rKH+?Cm?pe*K$Lh3Zu zveYdTaf7i<@^3e4Zp>tIvPnsKJ4rgR0#$uO<;T;c=)a zZc_ZYJs?8!h%u9sXyN7SH$qn9p|+Oxk@Qjq#FVf5pjNO&W_FYlCdK+Q0=W(R|DD2o z*g{|CKG07|`zD_Fi&)S=#(?ksXRbDum><{&+?FfL2x z_#@qjGlkrZjE4iYNO-UY@PfDQ3e!Wg1PqPOknyGa>jjM-yz> zVmL35PlSOUl!)M@L7uI9zkJ_7*M%%hrZMID?OmX7FE80dJ<)tfnfPL0sV(hwV(_s3 z=k4cidnlv5X;^(fN0j3tL>1mX9Lwa=~z$%BrPPwKc*=#GBLzGSOo4MDI~yI?XQ&&4Clvqm6za%WjF|%;3-jB!X=O% zwrBGAgVSj;eiRcOz#zD+K)4y4b&PeHkhkb6c{ijAal#KeP%v8_k6u$PLRLweXk>9G zy9Zdf*3t~lDFtqS_6R`f*hj5(Tq154uBv_SXch>tMko?g4ho&ON|d;zc3RVB;~=Q) z4q5R`JV4h5rQzmpz7CA;CDu75G~l-&EBdUlKaki9x&?Y$_kUa%W^?gKZPk;35c8fK=Qnc!rKL9LPQAX%>WxG$+U=6%Ja< zVTdd{_ypl<~iodFM`+>#TVP`@tif|MHx^p z+!0*zKu)b9dV-4gu|hwW1>a1VySJy@C37LiNoYXpWm5bx3|fm_y2FN@Di zKYV~n|2qbx8ab*VgDQaG=qzGpE(4hG6Q8M|c#_e0stYJ%MMBeBw^^xcGM})U;!sZY zXk~b2-y8WE_h*iw0>W6luRl*FH4X5O+}qz3J7VvS;F~%#0zhVPD|98u1zBG~c#!tS zfR+XNj8UKPTcU>l#aUpXLih#Z*QB9QFzRkTidwp=ol=t^Zf=WpsyF(7XHa$ zLzP^u?Vykq8a8Z!$L+AYtzkSiQ>bVMEAL@8v!H0j%Eo~&t}PQ))f&%1U?f-?+7>x3 zt_)ZlC3{)4FZVC-J79rh2_K*fLt{vW)~FW{n=O#2Iduwd9b}~PaEpi29N{?T)B%`6 z46>^YsPR0JUshrLB6MLE!X}Qhk~edz6uIdEw>vMWK`5YS8;vLZEXFuW{Tg0;PRg=R z0-sQP^QqXHpsWDZRdanUC3`W%1ZbreFqkBRK^|gW*n6KuE%nw-bIpwmZ9}zA^VNJa zLSQp;4IV8){Vgw;wcm_+Siy$k4?o<)}A0ggcC?A z{CK6Zoq33EaLtOFD$s>x3>weGiXcPI9Aqmzf$*h!xSUsP3Md+|4hbAQC&)2q5h@IX z;TZUJSEft}RZXKTU}uR!M1tfrfWXW2(y2a%xJ^XbP!{96qL&{SsC0eC|nwtb%ZkUzs|6lynd>89PrB#BqDu? z1}{Q#EAP$*1ZE3Ro&uCWpWFUTJ@Mw6nai2Sm*p<1D{KYP8Nm6Nggld;J3b*J1X1AN z|4+g2_c9p|{2alWsKJt&j7S*r>7*=GZw87^NFs67N>Nd`g|dX9qtA|8MeX{cu4N&Hg;{7sA?B;1Ydbtg>~vkil*0i_OvUq%AGMQc-_ zK_X;{o09>V7W&9p%gqDoqsn(sbhRLlaqD4JGoUom!lSk$Og6Z`)#fD%M^Pm;h*FDP zDrrO!y4bbQNU=MEz(_n@j(A*Mut6ZXjrX}@GpeRh0FMtm-CTruC{o+s7ZL~h4UJbF zG;@5PyT+!>i_b2%Dii^~hI@Wb}!y=DL4de&- z@JkAl)i4?n9T-c-$g1Z|dC7XU`c4-l4q&-bn*YO>j!(Pcm_B4UXy}c7(yl#Qa=>x1YIFE zLl0RL*u)}i%yjjMSXLHfpT!3y=Ab5CxFdw5)(tKY0f~U#xIh6$EffKCajU&rIa^g(U^0VgJs?Z~$4vEX3Bu?& zvdLsGRg^u|N7dj5UN%P_hJXUi(u^}T^$e|eN z;6ud2oE!{&r|a*F3Ji2mpZaQ z!GI@i3WT9SbZQ!1t6g%}zTB@|^WV{Mc56#QHXMBSZ#msxfnnU?CV~j47v2+DK`)n0 z(d|C=g3azCSLE5Rnt2&ySyqXcK*Tm1hZRKVdZrer@g(?Kp~+MknWB^xM4X~W6N7|) z)6L}ftVbRPS##4mZ^wrtGp7Q*4iaKhVW+E5v&%to9>0<1k|MQ+U@!4b?`iW~4UEyd zJ%aD5NHX0NLItNM`iNb@P*CQ~2&#uEPCHqsxPA|cGF8c(-6Hlh;Fq9i0hkIYxqocW zoD{CvWK+&ewFv&iX^M~mO7f?#4AP(P0E6x!D1#UqIM#!xlWVs7*W=vRtwvp%kJJM8 zkI(Szj(A76L$qUO?t3&`o%Zc1fNe`520gp8qCU*_)21N@i5)l*Hz?|AqoC!zmEA1? z1Ly=e@O+5BNyduzNRj$Pkukq<&x5Ojd-BII@JTZG?2xblooet`ga_QJHWVY^nxHTn zD@`tqF8AgoI*YXbeiWorUts_T5la>>7Zqq*!V|1Qju&J=5Mvg*3R>gDk|07rg5o?Y z&@Pj8)UR|CQmt%7;mT}?QMumNj}@Cd2!BQ{TWx~g^N*_NILR9gzF-g&jNtk?gOO%K z1)|AAi!7IZ=&VUGRcH8Fv5MS3GtS~KKZeW`|FUT z`_%9Rc>OTc6e0lZ8Zfx1S8t3+c>4wCQkJp}Z`ws_2nd1_0)#sn1{4RH2v6}+Uj-?{ zc9{eU&6v|ku$U~wjc`l^(zk5AvY2Ge0ZpIm6-DJ3s)Y;w--!IN!G*aQe@~-Ho0>A% zYS=1Eibv&~U+|#a>wM~o=^V(^msntciqw_Rh%r7i6y&Rb1=LMr^!ZLRl_wajU@jhA z5*FcDg9W~c&`batC|Lkn0#E|47y=SFjF+1dE(L0}+GcZ(6$}DFS4SLTu%ZaF8}Jc> zoO5I*!^JH9^I0-H+hTc?k>t4RTS=ln8GwR0v7rp`P+g@PggksQY6^*kR=cpsrb()- z$ZzOnw?huSN9k-7nI2l6#S`j?+Hs6WKz!GQKIQ|z$qM!)9*!&(FUJGIaI5Z2-9Yo_6 zF+YZxBnkvTTJ4Q#$a%h4-9q#^iR5sP1(3F8@R|6Nx)I<8#&ias%NvQ5 zB?@AKZV3qrNh%RSfH))h3yZ6<9`~YwX>cpC02pqCzU4g%p#W8QCCaB!%0DyT{kunD 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⋙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 z - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.ttf b/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.ttf deleted file mode 100644 index f221e50a2ef60738ba30932d834530cdfe55cb3e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 152796 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

                              =v_rA!CPE#mM^4@)}X7qf;At+v)G*FZd&; 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 ALjV8( diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff b/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff deleted file mode 100644 index 6e7483cf61b490c08ed644d6ef802c69472eb247..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 90412 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%0Ded40&XED0GYFoIh+AV*?9!MR5pBW?X_8Bp zK%Pi2&3!RUu9|qRP>4Z35>46R3-HSVQAZLeK|VoiF$JlT%hYN$P{~XnOQBRrwNe$3 zDkDcHp>LA~P6d z5;fR}J~SHToEBnMNz2J6@w`HcLpUx~OvPyi9!FGCnG$S!Nu$wVjzF!}7&Oz=YOP5N zluDpAY5uI%+w?#pQ9`*)A?4JNnR$45&%afA$Ec1MfKwMKS$_D?H&7v0tL4cbzLBen zPQeDPlx3w_N%C3nIgoP-8K(mC6YFKN^$A)18?Vabue>3{1M~AAzEmi_{6Wd~e6Lb{ z-=lJU_M=wD{rH(ghD>k)+VUf((EkY5=@l&~=XksKuU9Qu4%g8d8OKWX$(xqn1@$U=vss>j z&UTv)_xlSZeOiTS27(|;QR&_oo@&VMd<8K5?=eOImlmT%QOJXL!Tyye(QT*$-F9*% z*#9f>W1tI6J=q&SNmHXo9uajhj*RR%G9Uu721J-Fd`gHhd>XKq%TqSWLrubCXE~Li zuEulHFZb%qoX$;LAPb7tM0^VbNg3I|m2gIJznp`D-#uc@4v1}tk?g+`dxJ6<5{&Qh zYvTi^EYtu<%y^QE33`A2h(BQ9Xi_#nE+b+69x^D4*yE019|CeB*x}d$R>_s<4@xkN z7@H+2h}_|_(i@#xH3X9Cf-9@uzwhR88kGgGaz-|3lv)OhVs&1NN~Lfafmx}S5nFg= z4B3lDg@=NT8WnyX0iHq$)?Kw5n%Ks$z1Rs?T9!2ys2OI9u)o%eqa1Y9p{vuBphS62 z&rrmo?HmP%+nijX33FEf_=9ds89K))0VB5sXXVN?5RU4+dVSlip`gZ?FM%}cTs!Cx zvRkeUj-}URwR1i?$S?v}mI=2=a!%Ba$>Q1tqZbt`EDit$_A~Jt4gYQ5hBp#GV%++X zFxgngVF8klmS}*7(B-s8AnZK2wdru=S6g{b{h@;ij)n{kSUPd=P(6CPeH!Ktaa;m# zSaJho0mEQsaa#LtXfZl5FF6l~QzId8ol)GaA`+8FVKkKAMxAXpQ!(P2pA`k07Dn>kT@+i0w=sV?xguZi1YNXzCXwX)?u?)Ig7tC16huq z*9bgy-7nOlPa9@2N*Z@6MxvP8h(4%$_QY>!g3sp8y`AHwjD+E2%nvfM#?A^hc^?3VDn)u zIO^gzZq!B%Mpid{x{fvKpS2stjL}E^kS{9YA#eCCGgF?_lsrvbK;A9v72mB%4z?Tw z`wki!jYa&nnf)`KLMHSH!WXuqPH%bqVHw1`!J26?rc3x_j#j8N@ET}RRi)0qsYUP={P;@WeTT2$$5#TmJpMzcE=^BL@D*utX*mw`JdXpI z*9lzM%f5r#i)iIyvPc3&hdgr3?U-zYW{UayJf-77K-7>1Zu7D4%$QRB$2;;{+Z@$% zrZ4RnV+VHI*wt%V?p?9tjyI1!`dleztu3q8yGlcm_@C~mgfG5iz8ZadyDhgs7g=)s zM}Pwh-*^}8MPI$taqpKyK=4@i52v~hZUBrjkUnepnD%MopZ;q~j?annnuL;LE=rF% zQY*m(;DOG^#sV_n>)mL^Je!X7Vah~jNI3%|yoks;{|$~ukD|w)f1VEG(0Az3CZNTO z*VosA=Hy+>>(8Udfhu_y9nR=^-I!zSc|9Y84&wk$0E^H2 z?2#`PPEa0NKDlWa2t0NeSndSpUb|=AwprRLWo=WesVR~(yt;bm@Ws`u@4jd4^;6X@ zzr3cgsI{RayQR8jXxpNyHAi4i-XGQ+`V`3jdDp_Hqk-(Dca+|8{C4!koe~TBdd-e$ zhN0@}+GwOMtFEoBF6;W0t9MM%dUKTVnsCV=F>U+Bwg)2aCb6iA2|hJ1G8pitb7q1{ z24eoASU{qs((y4P!0FSYf^S&Xj3;8wWPq>yQtcmhqb>KHXgkt&;`}!!9F7z1um-FX z6JANVdZnkIXm3B^kWiP=5>~g9O1LVia39)|d`?IJ{*T1U(i8WImlO7D(j}+azY-J( z(68L2CyM+O!6!(sBwPN0h>6ilPH+1s>PB6t`=8rRfYy`mqxVyOX=kGM-#-ajPr$^( zBy-z8LHyxAgQZ`)&g7!5Pd15eXg7TVI&#mrzDC=LJ~)r(wSVI_oQ8XRR38f!;?c+m ziX?*hIv_^wWK%OnOgEx}CJ-SUNv04`3pVkhse2xSxt_48&?zbLbIDHwc3C~V^^u=nYmeN)$BmCfd>Jj;r1?ffM!fB4#%vVHlBB781miYh7UFw z%ZFN+^sK^6wMxy&gSjn*b=d_D9?&14g%^&Yqn~eud)@(S@JNw{XRh40`|#jUKk5 z%v7;J)JtjcQPjJ{6=I}{P>Xa0YJedOBO1nBqykUReG}a_w=^xM`lk1E)ycn)Fxg9{ zPAzfrZ5~!yIv3scW^uLdy_>3Y)_kf~|I1Z-tfal5XhKmzd&#j{*T2;2Pu(@g%ElJt z%+DzpTXw7lWmOlG;(kxbT+qR2r<)9supLy&u17v26I zirx3Wk-QJhJnAkgcg$MQIo(lQ?Do5H#=Tji6%gMVuc740t{V8X@ZjY%^SJ>wv06<1 z4Wi~y060L$ze|Z`qt8I3#NiN~I-6n!$uFTObfyzQ4kZo)P*UmpEz&oOm9O|lh=Q^xg=CRdPP}| zKXY-gt}**`N3*@Ku&G_{8@vs|Z8SLN#M8aZBb!5C$CP^kt;JlN-c{_6qn8VY6o%>x z;q-wbu`@MQaj<*T$o8=BinO#PqeHVbw5~28Jc2` zfz5ela{*cvlC3tjeFT@c87!{+NQQv8PvG@&PS{9Xed!D-t#5H1gd^^{?f$)GwszOLU?6w!=+T37 z(e6QO7FIt|TQy|zbJumWO$ASUz%U;$aN^)umF=N4Dda2?qrXG)56OL+67{Gt70Iug zOG;Z?%1TYsXV0J~RJ8593cUV`Ql6c;;W4w+A8=)wjn3Q=CFo6S$-IWU%9+ej3mlB) z-r?6C%kOzEcO0BDDZ@QJdF!}Gejf;ycZ@9qlNl&^t}*J#T=yJAW6Pr1NuWbrUj8~ycl!HU7!#a-av`_Xr|#cPdbmh~FLB~uI;c;rg9N2Hr6e08up-22TjC-b>tq}QV~V;W7?d84U~8I1 zw5F6x7(vMv_cqZn4B1Z?U}A`G*%0n40gA&B_G}AOD z;FTG5Muiq&QmbsJVMI&{88-g!$kO3)jZ__%WL0V&r`htNpXaW#ITJdZpZOE);WFVRc_+GlJ64RR}1dMPurj>^Z z__6)O`#@1QynHgiL5B1PVQ>bxn3o`m5M()`y`dAk4%%~b z?ZNODg<=Z4zbHUb0!8RYSKwZB=1#N6Z7Zm>x5<)2&<8JorWYRuC8yw`ZOdbS*i%Oe z+zA}_-VPl1G4i%hI2Z_{$&Q>{yCXLTe06EU5#|YjiHtPBjiZ}J=T7k!#q#+y*kN7Eij!h>FY|J+Q_N>4@^ z{dfN>I%X8^{`=?EnE?acZ9J!DvwL3L1~>HlRDYbn;n;(Bw z6W2Qv2~fep$7L^eNGqD|OQx z5F~np#IyFs8H?7O+=u!!`8s-a*ZTEW?1ZmSL#;rEYxBTGmSmeyk4RYyB>2qxz|Knq zhb)CN2Npt4{z5ibiSKm+-)k$TCsW#I!Yqkr5F(}%zzB`B!R(|{+}*$u0o-l`br|%z zZNei=;NghIxsfNLJvW()_@Y1_ynG4ax{_TvkL2b&oMW+NGvtu7}cmm61ttBi7nksHzW9VWR1q`7Q49G7KrI$62g zysCuGrSt5ejDSTVXBVr&xHYn^ZPUhlEZw|Q=y zy1phpcI@g!AOt?NdfD2cX>lO2DkA3-RcF8jPtOqdVgJg_f{8!W%sia;7iMyL8VCmm_W_K?mxBf_tnKu3J}6*Xh#| zDw%$|Kao!KhhhBm>7FjKQ#t@d&JS=LQi((l{xKKjAZlPNRZNs`r+mv3Z3^N!1h*l< z*~2qAUPpbTbEe~TJUg+N6Jn!G_ts~gK|ekN(Y^`mad7MU31BuPaBn1t_CW|{PkF8*ZHTtMYDOSTF3r@UftO|bZy`ueV6thgGu(+j+mm03uxm`>!hW&*ZA4^>^ zc4Wmj5PnlJa_kjXJiH!$Q#k?$#*V1`2Cjb?TrrSTNLC~4g-v9Ckq|NArE_2`D)wDr{tTp4R|K)Ti0e`$!lD`AAVYz5{^1qfAJ7M!0rY>Q;LFpx*oACrV)wkhWzg1Nrj6$I@<^e(UrfTqcw!K2jwqb^p_ZkFNrVQC;v-fA{Yeiostv=Sl_(F6Eq_t z@as(wL<%7@=!11*`$DkWZ}Zy_o{-OS7Wgj$Z!1ReOn#4r>v@O39D#HK_S+j`x|29R zDJ&I`qUV^CaoF9HK&eFmFA|g)#7_4+Ef?ur;h7!87m0x*+CoeK;04OBuL5R31d<#% zOP*-(p+$ST?nGtB(4NP^+;#bPcI^Q-_~+vE&dyE zVIHpf8MwiR-@$r8Dfy@1bI(YX3f_nYq90twPo;c<>p zu+A=FY#weATV<~E4-OBlXn1M$`H}N#md|b;%>b#J1I(C~*~_cvj5xpAniZh6^rTwm z)7nYKKo;#7v2x{zktn0>8n=?!rToX7XwAD7AAm-B&h1Tq{?4E`G zadfdKJwLn{)B`95=)onS{B-Y)p7 zByg`1+=%J;7_q%K#()mEIU<7P>BLUx+PO1%el)0m2NTTA=;?RfK}!}e&8QhXN`6Tx zqV4DZ`OZ7cksbwV#^)=6TkOB%E&%ojo5WmTHlDGXsTpLJf~2Vh0!rk71>nwrL<1PX zp3#rvcp)NUEUZMpsJhnV_jOD5L%GRys|CUaGYKbDrAi1Pxb&WDZ}!9?3f!(0i(Mscce~#;8=w z8y>6Y6*9U1OiU9P3p1>t#>eYmQ<^?QmW_@_|6))Z<-piv3>mX^AW&oHOmO&2gKjJw z?XhQ1)W|*he6k=i|KL}>rS0mwd=J!hkyM9rYleoz4!A^NF%}RXL;IAi8 zcsc>zF>=w5(67P;PnC%$aMdhI#r;LVS#aTb zZ8)aMQlr*rh-F|#C1pVqBg%dP0GNP#<;ft9gay(YuPZ`2kEs_NPT_&|r!$7&t}EKE zm<<~@Y}zo4*6)=!fAPr|&GNm}1%>kJf9)G}--hX>P`5|E1*`%Iuxg8Z4^k)|LmN;r z+VGe{q1!8e1~SkFnP=pCRW};ab8^xR>q7W%k6tBj8auX0uF~%TTIrl=IhB<;d-O{A zmR-BH$dx!zBRg>L-~kya`1EV9JxvM{4LHGOM%cp~D3Pk7hEXG^Y1BMwEgqbg_=2PU z%QL}*6w&NL(Sd0LG48Yj^sfifw;(Z$=th87g%c7_^ss@k%O=vp8fQ1+|ERZquNfYT zk3!O`jYa1K={bv!k-1`R@*lh^oY1QSW0y@#CP2RgA6^i%x&=sTk=HU7*;nBm_@ykgx{=-5vsuM_>a411Pd7Sq22ZH^Kx$6fHzoP6kf^Gk~?bG#e z1W=%NOlkDL*xWQYI%7k@yv6jIk*iRh+s32A8k^f`EI!@&VX+UI19K+tt*?^MfG&G% z-o{Vcf)IcXY4S(8+r<7Z&2Qr~50N=MkXmQulpfFELBdg)Dc%ifKW6+S9HgT$J+CJz zGN7f2XB)q$f1n4)(hWe~foe8_U+i)cnkE6;5zRm9Qv5X6Ay4xMeqkgFa7tncvb z!*JiA*0uWq*j3;!4~(uinHv^uIsmUL%qh&Pk7_`7qT2N1gPylp%`J(>qMwECB*jOV z;oBjTr^{ojKp?7WnSdI`)vruL5N=Gahnuwa6_aKTF?)^9bhqM$46thY+&XK9(c}hJ z>8;V^(GF7sed4@uF;?iC+P=2o@HezkUaF94q2^PYsNK|^)G_MM)EVkKkOqkV0a3aU z^@StRJjRp3_Qs2Z4O1b9_QW_(fb;NSvyXIOPppsnF&7b;5^gflbr~lJON3c9kP#>% zEU=*aM&wiGFy|rr@R;Eg7(=qh5jGn*4*_`*l0=pe!IMaVKwa7_8^UkI5-c9~@vZB00k$C}OlA9~k`Rw4!{q3;=JMlk=xF?3bE& zyG$1xlVRb~OzARR_DJV^2bTtAEH9NxjeItg(x%vp+#=d$bvk5D`{Y=bC-YjB3^SI+ zn1Bq^YV&I{hshPRTa9+P!;~8tTx@%hQ89VI5HLH!`FMTDH=H*3< z#(bbSJ3^b&T)vpkWm>!Q{7sMFxFIK$vt$WAY`F39o6heP(pKe$^5)LX3+1jNX<*Am z9d&%V$yrV_tPB(14LBUi47##{51?~@{Nu|n1IeAm67LM9$(C*lWCNOIfI-gWD40T8 zCzW!1<`5u(`BI*fNezJ^Opz|%No!#~m#@q*te;~}Gnv#;>EzhptbjQHi)N}f4RRZG zz7lmT+nJ#%lU5Yfk6Wy_v}B~N&q;)<(-uDr%~sEztiW`14m!u13xbj6v{wim@WN&H z?3p!d&ppc)is-)!7u|f#&7~GoS5Vhb zw+LPU31X_?)Y>2fSYjxy>ve$6rsS-opT&A5vAy1H0z#(}wGLsG)ToC2n$+D80SQGpy z?6$pUcd3eIENPgC9`lFCfu?^2a}095T5GiD_+mj%rdB0Unhf@wV7wx;$yXgJsP#7) zX6%}gd=hGcV|Q)5uD}m}Pi{I_3PztkjgH8Q+lw1Y&|}wWoAZm%V_Tv3yt25txtRGL z9|_s2@B4NTQ?6>vuQ@Q?>c?DL3pJiPN&THV3s@inUQh+5QWPH!fLOp|BriaS>_)Oi2{EpZ7Zft^&uzq?oBTMzP6yY;Jl#n3C64HvId9;vdCOans9+M!Pi5-|A!sUsm%SK`9jygfi zDCy0U2z&OaJSU)az0HB=YMh$kS2F@OL`-O%$jWiKu)3lC&K)~I#k6OGBS&NccUIf* zZ1fp9f>+1o^q6WUl}y@Vy~1#Rixrmjkmoo;gZpEw=t6u*r#zW!Ff$wE&%Yyyhyms+)Q&hHIm zl~}bhAn~bZcuK7*C14dkCrLCg5?F)2ef8Dy@~zjDK|srOX}mx9XZ$s(Ec z1?EmXcwCO47E)WOgVckV8u??&V^eBB1$Su=Cpfvs6!E}x0hEKIB?Oa$=zIy1B$kf~ z$pb8$@fnw(gyI??II9-~=w>k^27dFE3}OvFQY4h;45G7p%s`3{X!-?>@M+kW<_Y;6 zK3a#FIvrH#O*RXd9QLMpN$RCe?R7(D3@UY$ z>lxJ`9-NS}O$u&q4yzl+N&~r|O@*V>1+c!U@}NPuNSl)RNL>p==hONuYucdbuSRE$b_Mh3O7o*u5&t3Favnkd^U( z_n7eQ%;3X|mSVCO(YF?Bs1P*-uf*dq{kn|0mbz73hw*|MAuze<V1%k4U%d@urUmSD>7{n!LOk`r(4m zq>e>ZvAHwKv?YVH4QBRdcriDzdXUc}JMA1j_0zIytIDLdxjWPSf%?*Fi`uMpS@nxE zeVM?s=qlq9>8$@5>2)eraG@8i*V5_EVw4F&F7y!i>j!H}ii-1-Ypr_~#ns^VN)XZWeksY4GA@CTi&tQ^l84~QOuf7-~zRJ+#PxOMU$G1+rxxIkt?tRhS@Q1?{iz-0v$X|WYhf^;HK8HV#U0yYH zei$WCTzv73&j9Tdw4b@Bz^^p)0_d8s~6AGj*4`VbioIDM>3phD?LC(>O^y&`L!GR!@1Ce@7a}dOX&6;`; zQR};)Anr&CRsTbn{`YbjgtFZ@+|xK>_3{z)Q^IZT_7xTR?$!^$`pprv0g1ex!17Qc z>StsTA4j_NbUlywm!S?$z6M2EXb>@QO*w;!drl+!?~Vk~xwQjJ}_E$7?It zP$0usGqKF8xkzT1jaTAz)OFN;5y3emU`&z?Oc)lzFf2sGbTQ0hRv{n)t8xOy)#W3E zjUlR7?!JE_J0q$aF_C`3+b<&=b(YF)^*fx|^_l5u-qyU_RUC8oe z2$5WmP$W06)thEA1xb-#)(~=WmCn{U@faZfi??>3r-l?qhVhOJ2k&o(|1pvvVh@Mi zVmF!WR+}TuYUQZ z)PGase~gG@U6ALng#LCLiFX9duH&DS`kBJh0HDq$KsSuz;JE}t^&}wfbII;LpCR4C z`lrP!Ace_(!5b2u&BDB!_{YHCozc@2%$SQlKJb<}&%E^v&90h%C`rAA=Nous@`L%S zdS{;`bpU-l7v4crcw)Qg*<8KPMwSXP!pJZS2qTLasF9^YcwUYQXjdn%!UN<})X@!x zk^p#fwN_^YkE!+IJDf&MMx9Wqw~$ySpilWB;wWYe)j=pog6GSK`m~Y&@jToI=pouq z;57@1s=~xMh=@Wh5x`D~6wu>@X3ifF2uM~bmphBRJ}~Ii?y@<}jiC}}p(4F(?5eho z2WS5Iz$3$p?ISg5U^BXK;}2Jl+4+Y#V{Vu=rnD@p)Yh?W_)>pW+nBKp#R~eNMa`oM zfYRh-HrgEKhQfL}F7c#g+Ew!L-|Twc7oFU?q2)@)@Hu0HiyrOh`f74jWM76C?7Izs zU2|U9JHcN$b^4V{cST>G(wbGC?lR|=&8gSw79L_~bC$xM%T6ma0%OfZYrq&mrcLzn z0!6*sRvr^3p#vgThe1Gu#S5NEQ0in!8<~yboFD6h^c4m;7rqRB`@YXS-k^+uh2E$R z82E_+xqDE!bsf}BnVuF5*};giDfQ-(z@V1Ih#61JrJ0EjE_iyPK~bKyWZcqyhh}#! z%aeLcnci4&W7fQVvoFH;Kl4D1T;+2>l>&P6H5%{Ws65TEw3X9#j7^hj9GNz@wEl+t z-7{AXDeQb|I+*{&;)Qn0g4Q7qE}wJHyp_hurQ=KL0`_a+#}^v|&?y0a7l=S2@A%=<(I0-uP5q6Je$1hEQ#=PIH|Ezy#(5eQ@Q9=JJ^nGwM1iC(_o zCymex>39lBC%(I40kV9OeuGm8uO_%|4dc-tNQDR(SvUmGp_hUl%kkQF2#P*6%olGF{Lu|z4B8=lx?OBVLj%axn>VLg!MZaztjIuhas6T zI2;C;Fo63>;Ut9*3F|D`Bft(u1N$SgIcA_3ARmQFkT9pEnNh--mj@RH9gd(QIX-z; zA~I}PBq1K*_|8S(rREjoW->A#SKo@HY};DIgQJ~$gJ4S6@~Hou47xcf&mZ`!jYcMFb#!h3!IyQdxZ zhTuQy!{Pey=+PrX9&hOSdmch>KhhhX_0Tt9izhT{)ZOTf_csIiJ0Y(S1BLHzMnAq2 zA~pw#3l#H1>f73J|6eX(ZPR8wkvR$W#CiDD2+ok1z|To&!ErOOniD+Q6U}MCk+ZId zSZa914GJd{3kldlB2+gXCq|s?4@f*Imt>f@Go=yrE^*mJGEyUF9#SNi&3RvzDDb@Q+*f z;qO$8{J3OSD6 zIu(tRvtaUjo}M4Php)4#EzRkzQ{z!|AhT-cp(FPKm|f7QFN`QyXGW2OXBf!yUWd(O z$-8=xYpGMIgz}S+Q%8pGAD-ckD`)GJ86S*`%~)q^a8|C-fRl4tXC$A|Nwgal?wm1X z>d^V9UQ;<~Vtfzkd2V4=2~hR>!6WORjfx8R=@bYLT+BSF)sHN6zWs9t3&!X;I5TQo2k{^g|lp5FA= zn92}Ij|2*1V1X-FqH(~{$pgvjN3m9&B-iQ8mFUfq9B>uj;nXp#MaSkjyMLyj_O{3W z_40|&AMA?PuU=j-q}F@wr3sBsyzz2{RH=tmRg6X@E&sz?Z~mb|s#de^^lC<}mX*Im zzj}^LTfOTF+kx99jVcqh0aL)?{sEp2g^@0J;#Gs*#lF|$VYD|wpB8*Bc6Fk!g#c#M z-@NL~R*=|w<|1s*wzEqJ&^I8hQ0D8-uJZ!mHH+Ett!Kc{o*Qs2y_y!8cdDzC z?iB4Km;v??m4b!~b*bhkD`Gfvy+F=5tvBm(F<+!lkwwT$;gDZK(YWlES1b+(KG>0| zIUWWv^;dVCf3xH2t2>y2 zj;rAlOUPBo0iBCf7Zp`U&Y4V~khD+w&MR(-R98pPOr!B=Ry91(U;FBTKK&qGnu(U3 z+Ya31pX?VlcQ>MUZ~PR*&~Y>b9S1S60nReiD$pH)F$fxVeZQVn>eojcV>6By6?l5ZCSD`$)|kCl5B%z zVa#D{z?jS2<~Fyv2_YbE5+LDDfIw&nxgZDmHur%^n}i%tl7^JrPMV}io22=sX$rPA z{AOk)TQ)T9x8Ls{Kd^RZXJ=<;W@p~KdGp@qZN=-qeau1T9!v`#U>;^3VV+=~XI^5? zGQVXmh&aG3wU%UKyPpmT`H6ImrN*eNh!9{XAyI}HZF2<3PlRSLP>fl8#1(S_d>MWoD2)dw0 z;&Sp9lMK2%I$rPri=hDGj>Eb=GU#UwP6H4s0rk|T0G5E1u^P{_$;Pv+BPm&nT685k zv{+}gWN>GV$?OGVa*FXaknuK`VX^AL4sAdSZr78$zq8nd=MBl79^P_C%Rk-R%-j9(O{^wvxNs^&~^@wl|5nf z=8?0jqk-%DO)M}=FY{7V3j&?3 z$MHX|qHsgj?;v|}{ZJmRH>GpvZkf!8Pmf8ZmJGeoXmlh=m0&oRZj{Nu3_jh6(||_6 zflLjUCzmEUO!%K8NuorDfWxd(qZhdJ&huazI;v$;IhmYCcR?1s1}3~Lg`oA^Ic>)% z312;Y4v?esVYDk11kgjA2B$wQ;lZjZ(C_|_Upy^k{Qv^3>NHR((CbG)`L~})(Ul>u zLuK1%x#$&i7Wgzf(H9@*fo&ZSH-!ne7+3{3RD_-dKYxn8>bwj7y(rZi?w8LtZaf2K zwO4I=>7`AXzXlHxoNr|G_7~~SMm+9rVdT{FHIc_~3`-ao%)juM{lyn}u?h5yOT6HT zmPvpKN(3`|Kl%;ISZO>Dnl3hg8IuN~o1?ERniOh*0d#yR)Pd<)YV;8bubj>P?(Cym z4=(^i-ZItqht567is5Tb& z8)Z2UY8T$M>9H7%kTTpqsE#b5=myaX4&5Qi1%?1-w*x*qk=(HHc$O@9F+(FdZxg8Z zBul^|%sjkt?YXm`@7wqJ*>jOK{NXkLzd3a18vxONufK3)&B<5V4jgEE<>Z<$74E}!KU7tLDY{{Cpm%n}D)EnHY4r$qhefuVqaaY#Oo!fDLSwA*9Z0F8loosHN zbN>7cb~|_H;i}G&zT#Q)c#)qzf#>K6T{a05|L1b(>#n;&NE1*=D2=fJ{v(@llF>#F z=nI>1CJEyM`sl`Ce%rVAcVyoG?bbBQS*?$4p|T;#K`TW)ZWLS&1q2I%YF-E3=c? z&Fsh2`UGJ0*FyAJOu`L* zt~jSffnsbhU?y959;ZO=Pe}`wI)nAYgV|Z8j2aE*$}?p)wbiUl3;G=rrhONB z6g2c>k9JN&AMjbPzmDEpx^!Q{-yInR4t0h%gZxwuZ$^gKQ83w?;U&LG1sPuM?aW^P z(5c}|d&Vpsp4lT${O5dngIHQ{OJ=r=2L@A-uQEq&&P(?e2tZ*pB}vSda-d-qtOUv} z`Ed;XrFi`9q?iafz1FffGGL3jStSg|lzZBa9&KaM(YAZ;X#;JQ`ByIIS61eO$MVAP z$8a8aEWZ+LBlnJyge{AYa;5Dr1iJlagL^z?C=73+^eA8Oo41@8KWp>)DYn@^GENn=RqU(@lDD@_yQX^DSsqH~|ijHRufEBb6q15{P451>FC1g|5G_s+%6 z2I_@?V(;UR5GQpZ5M<-B6&pvE;~a5dOQaXn$1M#+zY=w=MV0F}?a3YA0)bCr?;=S$ z8LQjuf~VgS#V6Wije-*ZciQS^d*(s{(L@DowiPi+E_St$mL%5}5l7K^#=+ z)6Fiy-HrWD>MiQ6j}&{GCa!KyJ%m|+xi|>^(>n8vyTq^;zjiNXHVuFw@X<_k?|)ot z!ye!wH_(TB3^?a&jDh5r@jtJ-=xajcp?ASIU{ZA8t#6@r)W$|}%!{2b!-wBO-@`>u03p|&%uFV}a5 zwNMQrdIuMAuuOC|JlNUEa?~e9=bzv~8UT@5h|w45IvJypV{`?2$PimcTuI?OJQvk4 zcQVKD1Wm;Af``I2|MDRy8j$|egDWwSjwRdXIv;VvX(Di$#E${1>rVZzUI|Pt-cP0( z!GJ$JhM`yI1j)>aU@$a>Ok1S;?!tK?M*o!+9#^cv(U zg;JrC8@!n+i(aQt@k&-fQ-OQ;+|+sCraiJW?+E|+_ssC+cXR_X?RmEOedpWq?3n{} z@4PIeyw^}UE=LPmBVl4n6pp}R4oVFW8l;fZ%UD6+98#;)C@48D*_n}?oZ(F7IHh33 zkq%A}SXt-sn{K=9rivxEE}UxpC>&NAvr5ZyLc4NYp^z(QS16~fG;750&m8NH-4WYA zh+#QMNZH%zD~)R`avcX!!M+n~kaBNEXd-D@Y^JtmyMth$BlIbjYq z=n!3qQ?Yv%2wW#?mqwM<8=jy2tM9bR;ll?tEp(+^V+M4I!|UpjZhn%QO+|)nnVy#h znWdvYvAKE9ofLH#2QD$B%p^DeYw5;acf4`s-KCFP(5p_PUbnX(Z_^7e@DU(=p{MK} z{51Q_wmL!a#j!=N4VqW~#fB75Ttc3bzYvqUl;SjVB;RJSrOsJmz^}EsPgSN^-;Z|e zUX*T6$16G_fPbO4*gfV0h>!4Xn8zJXW? zz?UQ$W>bb_PpKYyW}`b6Nu7p##roe$oOv1iGBj>BY74DjRG*nyzi54^4M9dCW4Y*q zdOaKu^(iKh9Gz*jT8-e#7AH8h`|!s)BjmGD1ANqIO);Uu!@EDal3Nqb%naA$ULiaj zyvA@5z7z8^J|Y!j1f4J5tGfhtUD&ibFM!lLE2qySdq()jMbP{2w{-)nh`|GYTd!1X z|7`QaAm`CeM(lB94~T937(I*oQbJNuoru#u3iOA!e6>eo*n|G87k72YQ;GYb#AdFi z&qV4i7-o1O-3YdT7+8!?EE}WcTdi*T0<>Z6gu|EqeChB6d|LkI-C!;1phC;p@uH!t zJpS59R9lju^>@FyTue^;X6 z-s9CE0BirEex!>87(xVGWPHaf#WBRLJpMJ--l%^2|F%J?1@<>reALKX+oIM-w9zodnPwGa#UC<+R!SkAW zNZsR;L9h$eH(>AC2>icp1pJZLmdun{<%Mz}o3n`C!9>VTZf>4CCU#?d*-^0P=zrKs zq#L|`)W1j$qS*gouzHf@e)LgC|LkM9UUahQv)LUZ5i~IUOj*VPXkJ*b)g+uK(MC1d4%}UgSmx zJm)W*JbB?f@O19QtV`?C*@q6zUP@K&GCV%*?-0pTq34gb^f}9xoddr%qRw9%j$ZX^9OeP(m3MO9;4(W(#gLCP;R@ zFkNJbB_Hj?HX!NI)9NbC>FCF&-$BRwFTc3AUMjoo^Q|jB97p?4V!A#VPwkYs4`a zPE0jqifk#4L&uEn=~}f1UF{Sw7bM1@vp5E~p(M7yF$A~aM5g%{ z+7S1de~U0tmmFeK(!NJoy`Wo5dS6$c)8Z}{>D7dG^p7V$eQx>o>&EQitG8H^f$F)o z=k`4MdTdlO5n@u0tFwIOp+hs5Kg*VhosVAj9H+SLevLX)GS&>!Tt8TK&w`A5p9h+> zj5Sl~X#7*G8-hio`;|QaS|2Fu?CN?b{6JX`9il!IWj%4u6uOipg`Tr#uv=sDpU$I~ zcF1I2OoVm}>p7neJ0-@Sy7bHQ>U%rnR-90_b9m4Bb=WB}{?w&^GS9+m9Gz#&sLw+) zV=_XHZtv;?L4Ws07DV79u^RDuc6SRHs}GF44?K^e_a5H-*>(k?EOZm}*hH}qZ{W4y z8)AJXiZ`xy*M?n_gr5EQ0rclR2F;$Ywj2ifN44T-J26pw=5>SNbupufC+LliNY8l) zujqsbw>DlEiWn}II)PkD7^2T7a$9DL&mZ3mb;JRi;@?JCU@)K$WGS+Ix%^r5L5#-# zlQIJLvvPSpPTUdht`b~;D~vu6Z#*kfK|BvV3Ua#IM~r+{d`std*UhW++YtGX$U}C4 zr7>hhfLY!yHh{2;v?TZiv5y}W5?Yrsh|#;LPWTKmQ^k5o^vz!H!~{0N5&LNZbRJ_y znXc|kw7nQ~wTqA3+TC062_(#!(BB=8PfP+4C%=w9f^Up*7BjJT z@r1tBk)1HIF5t}6F=vL`qm~fkDEv}=uv_dd>Vk7rXiCAq#ob#kTf6DhtFw;+?ZfVd z6{lubZ%LD9Ds1MQVwYN`$sI4)o9ip88^?!(lPil-R3AQm4*iszmTWUajc<6anLRoG z%#(Xp{AIZA4#A1B^Yn(*F191h)`8~sB&cSnC9hk3LZI& zqOavO6z0lO$FrJ-c?;rl>D9RHw&3+dh#-3~B7z6iJ*VsJpy;#9OtlgLtq{fI!4YgC z7OW67>*G*e1QX6cm5|uCtPk-}r(IZ3wt3pFy1{@Ql$0t-5)2xtw0HoYQC&JkDc7{D z`{uzJGamc~;nS+&KOV(o9a!F2wdxJ@&B5P1jHYaxzv>NG+$iJaj$DsFl)tBC-dO2` z{$^HXGHw%0HF7~(6ZRJhXm~6Wd|LPBiEoBB^Rq}M=mPrYja8Gkfc;PW{vgho`ap?c zbcwh+1}Y==;8wsZmY~D$(BWT~sZv5%--X9PeYembQT1iWPhu~vFDrF~Z?v_f?)&1~Zt~AuK4VJ%EL{cu zr)#P!iR(rS|Dg5rF=GL6L8q^VvPoFuo*cVPQbXJjDY;W^(sH_@2*jIMR(bOX!%HYP+yLlS6Qr95T|^ zJr2K*rK&FmJgc>~qVI#C2F*l=@&B2iCWyXoZ3PVI4_1Tzh?##`!k}<#q_wk^B`44t z#nr;oRk!bHCN|eN34P`Wea1Wu{Zy5r>*-9NKJI-J*PA1Jf5)#cX|?8#HnUcH>DL{Y zFZ+QyJi<9+TL1j!&d7#m_%}3JS(-QaXEv~r&Cj>DQvXKaB7s5b>61x(cdjUnxbgd8 z!uy$jS(eX5znHVY?oh$Yq*&3!i}+s6ZI}+NpuS2{DK?CbP7pDd z*F;ESw#XpyvF>q^xmpIqNH{tR1%*{(Jw4gySIeIM*tp?RP zr&3#gQn4NL~Q_T!zI)Mb}K?-nTI^P!z0wcg= zFdwW0Pk^)FGWZ%qp%Q;Sf+*&ucw%OrNV|!*Vvk!Aq+tqzA`#ON1%!YZ_%ehT2#qJU zomt|>OD!P;Z2*`t?`#%x0}i;LK?L|orm{IO||?1f@Bj!bnSK*T?ulAt&C z9A5PqZLEa=5xE75Mdal?nFNj~=nJvLy2~PpRDob3+Nik1B#|!!Z1fIA3UwNVfcQ=m zLAS#Nv;=^W97)Z{B1!Z#h?hwj9{Zow}xi}7wA|2%$)Q*`y=l29+uIK4!`1>h`!%pe{UeiMBy1=jPZrA~=Q z%?cTk3>*;S$a>$*1_%J3TMaDY*P(j5>{-i0)7!y zj(ADLS@8i8KGi6e5_}?c>y!NuG^F4aDQ0t-YHUXSkgbJT1?@{zW5l2r zz7DdTDH#EGNh;qmyuPKSZTjEVq%68+#R&ML)F6Nfkw9UiIXWWxTg%v@G0y|Y8>EtC zb&4QUq^8+amQ<%zZ&V2WMukkK83r@lsl3XoW}!S=uF+VkL1=NR-6Yixv6Qnc`i{;7yud*S*m6sa9?u)8i~0^qQtK2sGQer`RD7yC z0}fZqq{>FWTmVMB)tPEhJFF=RxinQ}L4TJu*tnEbqkWh&S=HaB;@MK4W{6FlqcEAZ zwyQ7M8e|SbYD!jGwJO=^()fa$>^XHGLuS6$n#{g0)v>Hfmz4*SP}|q{-~aXffw^;l zAWvJLF5`Igqm<>~yO5Je6aYs+xW5@&&|TW>GL4>P<@|t`S=T0Dx&IU}9d@v+u1aGq z^`-NiAcqo}pp_b+CBZ;Jo>Holm8XFbtghOVeN!Xv+z{}MQCYa( zyfW>?REY(q%anO?1AweyG&I7Q=+U}*skC4C;zak+p#397x%ti4RC1GwKWq z76M&arA+EosnRlWn?yIMwS!hDl>T`Ee?5eKKdLNUTv4)ZDkp=OvKuT4m11Q7jPoYb z-Xf=&WlgDlBcLEq<#vFfb-42+8TA~`Nne`WXGdV3U#VC*P^&J&Wv{3FLVp?HU!+`l zAL{SAhlT>M;WqUZ+c->-BtnSy;!~zq;D2h`Hg)Q@=+dd%nwqvn$Cu69dh2h_0}m*> zy#4ogPR(a?2F+hH^x2tdQzkVHbSsA+LZ=@@AAR)VhNacjj)GkB&{X>9RKBS1xLRM9 zMa|1C_JY#EBWBL;cVxV8*_2r$>ihcAwJg-yN_<25j0%p3>l?)UR;5$q%vxqP@pi)W z^yEWO4|~8E8;UU-f_Zj4$NMS#vBn~*vw{H3rz18b&zr6u&a&(v$k$1Ie!?k{Axo!!O6)e$}JN;~JFQaVq zy(mhXv~lAkF|_Bxh0fa{MGmA;wsD&>nTWe?p*$T~hxv5QUQOYroRq1zT2--Gh+K^b zcpau!U!jWd0=18?^-r$4(poina+MISn(VLT7{bR!TR}t==68yA@5fNYUwe!sV`<`J zwM?%vrF4}kCX47*1XD7&uBe!$=NU+Cgc3{9tBANb3~a6S_bNiPsb?91{r{poEMC_B z|5P4`xzYc#^1!b0Sn#N2{wF1o{&FeUf9w53j>K~}i`dJ6`qD7OT}o1qAMTiIbPKnD zy2se?y4;v_I=N7B2AwllmCCFvr7}eizO#9& zEkGOQBWa-=v7I;- z8zD|aqqqlO!|937T=6N60dYUF?L^>@BSfDFBot+64~jt2i^u~p+#FmnT&MId`H(N> z<6&&iTJ@}(&Ka*ENUWvPhM~Q0lLJ|fiEN$2kEr}$8?hwG9RmvX2_nL5`tXLu9K9AzqSxNYt_G3mdGpOZd7Z_onD{S_edFo6Ak4X~& zhOoQ*1QWZ2t`&(pC^xlc4pQ?qzv!8o`0La;t~YlQ?n$>uzc(?=dj}>QdU_Id4KnZ%Qyrxf!Mhk#rafu+E_S`h7;A>H8Ae3a)H!W+b z&ysMr2L|x0w7)l4#R3Ft*gy~LA-=1f2;PB}@iHOO1Js!R$i$V@1sLiX%u8Kc+Brat zxv7<^p2M{b!Rsui#?Rff2~OKIcP^N41pRo=%J+{*;!>S!gBO)ji5L?%~t zP*Ts~=>U(N_`PGt;*m`xSuC0x+MReZ2pu~XzY~eY#r&a43GF6&tbV3~8OyRYE}-@T9sj3sNqu zoz8BsDXUVAOmqhOi)q@LX(sR&x^-AtRZvh>!0noJ``%4^Z=W=9$&6-BU#I7qXDk`m z!Q3d83lr}I(J&jqS+@VZ8=8n$;Fr=+*`PsXG@vaY*>_H@Sytt6R4uDf?0EaB=LCmC zcp+#=$y5>cj%G-wSS~{?k8Mt)UP=m!{AXi-cijSZUv}o>JvUJ!y{`YHA6{=|Ozu~W^*QKYgJN?%UJ!QhA?0x>Tva`6i zJMlR9cZxom9W%Nt@bv7jWIvF3r!R9fI;oAIuw$xNxzx>*8ozoS(Wc!p7?_e%c>yJz->|fXHiTTb7RkSv9lTrtbt(Hkbx<@AEX_ zZ(PI>FfP(8PSFk|8N>k?0c{!FEdH2U;qTFXUN@dahcMHKpI@G=uS79R&>^aeccD!4F;yjj zm#~EY6d{brW(@5z0#EUINmK~1t~ew$Z;IiL1j*JUOYe$y{zA;ZLj~|rvq&Q7;klyI z$15$N8Xk4bJ#b*|;=Caf4$SrD!)15?ADBM|Ju>l*!^drzRbHzRG!#{WFbSbgQuVo7 zZDp}h51MS5Uq@FYnfYvC{(4|;bVlQL(`XBPZO{;P(BZ9;AClJ>Ut@4!lS*nexy;33 z*)esH)m@R+`m?Ik=fbsfYv;aNnLDeKF^pCW$b)zLYu7r8&}DCEp!ed%fqBvq{+z+O zon3v8t_L$IHXiOtpv%c!1#opSE94`1#4ym6;I2hkE`l#hfDKKK7;=)&K{YC3s{%5t zNx!x51erM|{90GBFcbD&(Nd2h^)2Z0=qL3p53L0Ez^d2u=#P&FBktJ~!ju+u{_UP~=m_zO za{7*zdi%=9*k(x4MO+ zDsRdwRDdPo;St`hAG3_oEL=TATQ{-cLU)C1_qzLJ6>v&)$mnXs7ndEFlU$ThXb#G67FJDEZyq;tgK_pq z5ti|)nTDJANOhrF9o+>!cNbO{DD*0H8U4il@hfXhN&j55*_v$!yKT!- z!6!2&Csb<7gQCxqxZvy-Gx^pKCs5!5}LD5p|ELl1;{v)Cfz066y!ALV+y#ac1nEDm$a>qB9Tm|h+H?Ob`_!{Zl^zCE)WBFL$ zdosA5_!(l}n8=UF@9xa5Dj6aYzzb$4KQXDazEqqhh6M10F(fc=zga$gNI}WsK`CjI zH>6I~HdjT9MPj&r&Y(UA{%i+!^2g&j0Wm1@Mxd^Q62cS{Xla`Ees*V*BEkL`%BSca-=T0Yd&OOi`vqKYq3H#zM>gjbVvw?af zNvxt@$Hr8c(t(JzN&tP$LWV>`!3b#wv}CB+7=ooZeU!NIRBJF1{rF&f3K6?Ch_yIN z(O*2`+B!fNR~kT;U%a$$!A{F))Aq*bjJXH?syi^Zeq*W*6RQ-{faT9Qg6biIg2nZi zK2<$tcA2bF)h2nB7e^nHg**C5uguD=d=*os+VDAbRhGY&OU)ag7;V_88=T`GAc z_6{g1BQsy-HuRRiwhIqN_%+8c$&`mQ-B@#{*vuQu0*&=32)BD(?)pE7oAn&YHDdajOtV3fB25>U^gioADxY8jKml#6x<9?^|Mz!IyAhjsRZyb+bj1T*ZlQNko_l8{Xk zPT$ut>gIc^2A7(!zjv^x?SJ#BQ2BphTs<`9WH7&2TO|6a1|nx@wt5}b6fS*^&I=(P%t(->21 zE<@e4rXj8YTCGB(mHJg0R-5N<$lv$dmsurFD$ked{zcNgue|KJzA>ZsUB7_@3Yzu$ z1{DWYET>d!l){Xmb<ZoNu_50RVuFN2F(skH~5BR9EGp7 z39Y=H>Xa}t&LVhZASh!!L5mCs_&;nTgf7|yk3HBl7}-JFS@bD929HIX@HJ>d_Ormz zgd(tw2s+6Pnv6uJlSHv(&eexwS#iXZ)N zoZT6m9e%J8T)jc3B=YKyWDK8)%V}UzW1c7nFe7mfjr8;i5Z_tlW9nrA>S&kxN};I; z)z6HDe4?7Y8c-lMKp?t`ZO~K_f^kh=gF{W#(}_fosC3}vIfXBVeyTR(pbo;}_MqDn z40_x_ZbNWbFgUE!v-sFz{Ku_dTt9rt;$xiyjxSwy{JyV_a~qB?TY4N{bbgBd`^+ux zu37W$Eoa!12)%>OqUG-%oG^C(1vmozh&B+H3Scb<*5!p{3lE_yhc|y+U(lc!ZLj}k z^I>%5&_Y=#4=mUZ?*6l(uyqIA(f^o1#CBR-gn-O4$@28h>g!4gw`$1Bj7a(R$w9eG(%56Q-1T1pg) zY=G^HwxOSa9IOIzbl{nd8=u(-@>HBEE8ny9Tn$jzY|8X8>HW{4zo(DE!E~S){N@r* zeilw5&nyf(cw^Pzma+-=yWEa&VJ2J-M+zT{-9UTsUj5fhjI6QbIx@tu1w zkO*p+;Vz&dqIqN?T0%xl_wbC0FYz%@QUD3>3bk&#L~FKRCqlkw(xyq1HUXbJvroF* zy=KFTl$7*7nR0Vh|B-k2ZZ9&MW#$U=nI%K&Z#Je zcm~&7FZy>Q3mvKnjmbgG!FLddTsx*3U96}it>5@*J&w+PwQXV;o-J^KeXapT zc>Vt(deP}E8juP0JNU?ie$lIsqt>ssZv6^`ABRGCV#j3%0a`2?;6QJHfMY2o|FrZ#TBn<1FcC2qgNq=ptVVY}zxMU+{Yp4+u!7v zZ(mrMR6PZRFYPsimN+h{z7)W->Op<1;4J{QhoV0^X2Yk8qSrP90M4?;H;R{z;oZ_= zm|E`a)46L#1vs4J0blqBz+zAUz21R;t$uHRum}p75&()|s2B}&M3IiY>Ml|POjYu@ zogLxY1Uzjylf*2+T7{Z7SEe4l?mfK7dJbKFZ{520Ko%GXvflgj1``b2 zXmyj~I7Y$&(gkZaOpruh5EkCNaYEnMABK93N}kbj#NHogS*@7^T{cdYmc`b7wn@V( z$!iDqzwih!Yn2j%QrU9IhSTv?ss*JoRk-$(4N6F=pc?!q`to&&1%m7U86O2=bE}!j zAm})N?5?@o_;Up^Wx&h@SvQ_Zv@WwAVv6Ac0qDsj_#~LHu($m1`>$6;t;f($KJ;w_ zER22(Mhph#Ltnj%?te}4+j4fsg*(1NKY{&?ikYai{q*Vf(-H=*-txUi_P`$S;60C^ z`O!Id>`Oxxj;mnZM?eugfX<+gqa!z~;i8S8a)snHd5DZFNctE5I^9vQGafgzf*>0r zVu~OcLoC(#go4E*u@OTcg0-RM@I2_T0b&;9B>@XAJI5HzPz^YCEBX=*m|w0Rc-L%& zVu>o}yJdlmLUOHdv{a)=<}Kq(HQV(jUwyW3a*eB^Ooo?F=4@-}*Q|H?)%3Jd_blhB{ktZu{-nE$)JQq1@PeuPu76v|)h zpF6ZPMUeSCkSouGf?g$Mr;Jck37vl^P5l`9?H5}}-*}3B5EOy?4sB~*aqEghuf2L`<<^z+w%*C7F5I(j zQv1%Fo$Zs>?O8Z~6_D=x9#o%xiu5F~vhzwSI=QxTR4JJD#UH`6vXT96L8oHt6D|I3 zKQOtBpQ&U9QhzrNan*|17E)?lNTP2M)Vn0Cp24dV0%S&DaLgcAm#>@n8ZbWdw@UCVNVaL1YfprmM;F%495{E> z{5?0lIly=I)v05a-nsf|?=)})Ugj^~vFi_TY-!=1S0;_R=cmmhmjPkvvAz$1=AVb7 z@9=~(1uVA)r&TR`_$l!C$Y}!$9$K`uW6hXJBL{!78_IO>_~BN0rNc+baW0 zGrejyNpIkw&sH`C{ZLq4&3z3@@Tu^LceN-N8gqsQZ?3cFRAe|!a=meM-~6FvKBo@6 zTg^wpqf1w8o_A!*ID_o_2`8JY3;87SVEfmF)$f4mGxLWGEK*vlQmS7%e*D}pcXn8% zR9Fg%>@yzg@?FE~vIQ+5bi%AzlZxb)^8j`eD>@ymPYxP)c{#ZvE0=cu+!)4+k5ft zJ>`K^jTW!=T*~HMg9kOw8x&r+sp*L=H9L2_c5a712}s zoEcu?K9@Q#ws5Y1i=fS54h?s9%iMAfkiZEOyeHr}#o$Mj-T z##o7|Z%JQ0`XF!o+S9XU+&i^jauomVt6TP-)_A2bUx77~SW@()67p+r!EhtjKxa}@Rbz(Y5 zw6x|W*o4N>mAh?oyF#uQrlmiIamn|(7IjR2!CF0LtVLZ}#~f&5LP&_Ec)FJ8fGHu& zMcN}Qa~&Xys13o?m2~T{G!gRK6g!Hx=%Q9(LbzQ|Ob=nWcTP0eqkS~g+kua2v6&L* zgkm$%x%<~xp#P#laa(bCQizJGBg8ipUKJ8aba&O+ME_Kg8@3vb0mtHL^wD=XruDiy zi{W86Zm7DReZqq|7uqLW-4JJPN|n2O55?@zEoS5YSv!m+R^~6fAljI}_@Zca9>0F! z1zD&4KWmyhZ=7A%HER3cwU-gEqq3M%f)y(hL6c&w6tmXw%(MkWJxu|aTdG}~zTf6y49i|0*?(GftW=J+W=Issa(ZkVLA#E)+4RjMm5 zVcgcv&EOHW+ls_fhZv8KqFj+9`73d2Q~UK`mz>-jM?Y}Ut&%R8Q2;VkA!_$ou^T)H z^3c1e5xol;Qk^{)^r`xXK&vLYn7jnuq2a>feUJwptiv}i>>=q^K7`-x!r%ErI!C#v z9u5^jb&FfNKNdl1iWjS!n#O<|2pegVye*gSOwDSi_NFi_TBR~sshuwX(L|M{IBD&z zS*bf|N{HK*`vd;!J5vcDBt-&qTf?axA5lGjE88jpgyG~QO>3(tZnZ*LFS-xCe^UQQshkCBg~rS~)GljbVSmr~=pBy&&&iWax4*Qma(gMFYcKnt z_?hgT;Ng-^@Z2yzPWbZ7fYuF+T@@m7YQH<+Caxv;AoWc}oWt0_4QuudYDP!izGK7K zlqBz6H|LfOsCWxZfBS7Pf>d~5?W?H0s2{IM;#eNYp%My(rtBn};>eTTq7L}v_4STy z|Mu3FH-{8AO&C!*-z|}D{}$-KMcW_6jUj!kzgmjv45#HZm@Sn0Ev4SUS>u4@z=rQm z&767aJNg}E9K-(u_dp3FXH+l~)2J}qKcoF^&=?@RMaljKjjV`k*qo+X@ca((T zaP&TjrEQyhUZ-N0Fsprj-N95=w^j}}zJ}s|t z@M!&lp-B&V?;bs6nI+F0?B|<3Q>t2B7G4ELcChW=qN!*E5RQQ=AgP;Xx-;uGscijr z^x2rJzxvha?N)HBLdx{O!C}c>2DJcS4G!FaB}_ZRRebz$bj!ydg9#`8dV(I}Xq(3?-5^m_j)8&@J1o40GCBNs)k(B=d_iXh z(G3Ve;HP?eew_m^ulTJ%iF8vez?$ zco-#mhIBK=9@~J4!Lz#zAz?s%cAQV?#qwmh8@o<>*iJC5@;_VN=NEIaygba=AQRky|X26<;AQ z8@q<~=K)R}aB2*Z%3v z{bPRr>hsrLSaiI>Ztd?wTZ2PjpawMk_D3*kTHlS6hpru3YSjS158rTSysuK-dJ%~} zg<)_vi?I`=GZG_`E=I{GV8d-Mr~{44ZBH<`Th9;emJOJ~tPo{o+Jvd`A< zxG$E;fxR2=xcDP|`g@uYZAUw~avWy)cO>Uafc|RBq*L8jZ`^4KW!v8?`dT+sPN4=GIxwYvE z^TbkxYPsMuzQ(+4{Os>KhoIS~>+)A@5}|bPF-_c=z=YIP9I(M2&)~C3C!S$M+oZ*R zkcpq8k(OgEQ4-zt5QL@FJcW}2t7<9u{luZtUR*TN5_ZfPse$@P))d9KWmJyY8h z&s?u=GNuIFb)Ia0Sxv^M`3K%TFn?4=O_@L2Q|At(7|RCXuQI4in`sYay5^Nf^hQNb zy#WD_atGyCsA3GGB{o7n8tSF+vUYfBG+GMa(;Lz7Uq?5o9+xP`He1Ma;1Rd~sdikqXAjYjoDEn+ z7xCmVt;bEpSDD(bC?b-g9D-y)wO`N**-1)edaB&A`kkA%d>)uzZ_W!_YUhy8!I_6I zI{5nS9e;l4hjaTwAoQERfC-jm2ivDwvXcx}rGC&Ly|ScIKNT=rEZG)=Ri&RlU$3%S zLwfL3pDCvNf}~VdUS=CK_~y4)@3|>;m?fNNuHFCc{zb!XKlj&%4t`;N<_q+jKP5kZ z(__0FDqW?u8Ng<1C{tyyM1a}C*Zkbe5m|>7Z)wp%*#*JUM?u_QK6+^WqRE8w9f&toeEF;`|Ji5FEec*2%+mZJb(G(lB?9&s&q5 zCYS5ofw2Lt0f5jjSCTtW*e5NyED#P34Al4%?es+Z_Um>QT)nOnopi%iz4{tml>&SO zJ+C6Y{c$%zI+D8uMzJus*30WQmw-)Up%NWpZQo@r&)7pi>&1(Epf$S^{i!9&A!66C zpr_3{I0~}b_v~p$m+=vNPs-5RT_}3sdl$Up(LL>5PYvr)^n`E^-j;YhysjmCxHk_c z<^WoMsjaSSAGTNf{L|J6CfaiTtJYZ9U7!C!6ZF=daxoPQ<1$c#X9~RzFmq3}yhSDX zu5+=O2#!Q=d9;nhaKLVseC%WmhP11ZG=qV4N+ylDI%*7?nG6`Zpdtq*ITLMkm$)&F z#zz9x6+y41noTBiDkx(IbzWtKBuAoGPRFmVF`{1zLZRZ}dp`RtW`{>kCW>Cvhp8cU zcrk7&t`8jZj)CVc59-7mq&l6k&p>r+iOy_p z+yeli&$N`9rP9IP4#qoJx>Q51!Az?Y+F^DHIl7X;G2#@X#0?^`bCVr9OS17jrS(hz5bX^GZp$6!(7z?w6m^ z_1SRZJZnD&MbKFU zR>taBqDKhu_@~yGc#u*APPS&>{{8zlf{W+^C`N_XCV?<&oy1&&zY8yV`0USTA6^uW z2f!cq?PquF-`6=6Tm;4V|HbGL=Gr852A#nVfEGMfUweH`QPG;$K^Y#eWnx$yn_1Tw z_HtLb7+27v3wjJhia?Yq@d=K41pl*x8PPA%ALfH)Xvchz4O14MIt3PWaY@sNuNdMI#*hs_5g|{3VnAF%$UqSZTbkLV&b#$$VJ5f$ z_o1hvKfH>HUzHZ~g);@UzVmK2iC#+CP^S#8Q01CHNvBLQA$m8QVTo==Z<%sc(c9R6 z;44dlEUpcI39=(oM0}_Eoq*bydk7j9MW5u2WH~RYR%VEbm7+@!GFjlc^w=?WK=byk zSDQfNm3`|`7R5e@Odp4$&#b;sZm2VqUs(MNijJH912_V{0!My;t!>eFCuTx0rM9Vl zDgd{%wLX7h*198~%xMIman2`4*3CNc{M+JW5XW|i%T~m7mVwE_{D5c^ZgTn!)JvJ8 z`$x9{fJdN4EwL#MugrM-*Gs1lvYnls?2qUq7)?}mqfM+wDYc_5@4SPy*riIPl)Eg& zOSWgxT)6#XeE57!s3R*hW=x2?92x@`MU zd?1PL*3$$eagMH9z2ZB0{=I+HQ0EyN(K5i zqd%FqH=o-79K873hBuZObXi(kdhX0klSk>Kqi%b6!*Y9-gw4n_mE)1Ww(o``cYX9K zDBd=><@AGJKK#d(qefZKvmgy7siA!glc4ujKzFyO7kb7E1kUbqtLZ+o8e;lNl@l-p z4f=?xxvw}FBCz<-LwNkyh~#>$MVNn~oX^it=37w*`Wkgu^OY&qmlwbkYpP6cPL`?j zw9sD{|BNn4k%U5$l#+ajS9$c4af3|Bg>o+2xP8^C?Z#|QUYKkeH13n5 zO0VQN6}2wz^(GRUzxo3DqSp&i;f++(aIde%^!xc(8xO`YW@;)!S3d>{dGCp7cjETM z-Cp7aR9}~%H{!|71x1BwBPb5iRRys$5muY*t{~dN1x#PF*d2wIIo@Lwno`*jVEQr3J zQwrGrdEgQ0;&qqrzIEo7-4`a_wj>4Qjs2C4uWC%YWD)e}OH)Dr;;)V1p=Odz`%4wu zm+fia_rkvIjSF_4zs?WvFzP3+mmgq)A|R-txDigHLu`=ZUQm}tRMW*PDxg5S8ftCO z9)g(VOyqCbmY5r3;2AO7W$q`SZq>lzP&9GOa>7U(N}u|G56c?@{M> zCuhw%`5oZs8SL)O6xYXd)Pv89>&tB>y)jio_xP%veKMU|RdQx}PM;KGrBc!$Smmw% z1^VOc60=25_hO}Sdw8y~{5ZNk3}LRNiP+G_r8&3-+{Ew>kF9iIV5uGlT@9xY%^y1E z@FI~lh7+xD?%{C~tRL!ZkEnY9Gf^AzgGVD1|6glY0v|<{=Id2;RrOhY zRCo1}zS389=jcw-S2}0sAO>@xW_Ta8}V>cUg4> zbrya*6iq{AO6V)hSS&tD z74g;t6@bFm5ZhdYLS>|u3-1wff>6oc$<(DYnRH#&Tju4=;AJ(96LQVn!fqjXsK7?q zteUDkJw6redHi#WkJSL2P#Y~;9O|RDc!Jq)Ni_j9PhNkbJUQLnl*g&vtWE)D2)`(m zlQ^jgDW3ypfegnLaxpg=ft^-hGCSn7DyTh|VlCJ_Y%P*-1R2Z42LW~jc|x=a0umG( z(g3cI5s>Bx+KWUY@hlLA_(Z~Sx5%3Vu+N%qrfs{=L0AOt8fx=LYLyx}-+iQMkw+^?zoa(k@kFvhoqTYn4Z(0?&TVXn$|-K_q?;{Ju1yga!h z({o2<<~#)CWc0uY@yV4t1lL!+Bst*L8`wM@g&} z%3_4IH3Q1yrC2|t{JXIGum`arF%Dncaq;C!JXc=b{L|T(xy`6c6gHAAz7?B@EyPx1o1rR@8@0qRiYB1JaCDU| zAXP$yTtib&j06(b8%29>cxajbRwDeGX8Jh;MyQB(MIj1`k z@&;<^LqjLgs?4I)tVtz&I5sOOA*`VPDF+(ysd$O#34&5UqH^oeqxT`zj$;qp1Rn(d zfsN}$Rqy;xScOl|`REdtF?lxUgE1d_QPk&i5%r?Bn?M=5B4XrC4tNnsA4Uudr^_UF zSu~<$qSro@cLCln!2luzO*UajCY&g2iB9D3^5B`6P2Vpj?jtD4(;cmXCx?G4@m$go zYeW}>q-W%VXs)>u=gcHx$})MSRbS(exA>Hv5`T@}ir+ANR+;-mn5=L0)-*>;2o2FQ z7}V$a3?`Gom!}U7_E0*z@cGw_HmKjDVz~dn zeKunMNDrI0*kP6W$mG7{mAwpq=TU&M121|Op2p)Iz9n9sFL&{t`0cq87h8eBYty^* zU~ZSMMXylkTYOz}aXfD&?FDIbsiq&Ob^`reD_zrWs~j^?51$SHPi3*P%+Rt%ID~o# z-|Q5=p38Y%QV&q#8|mTunR}0lM`p1`sKfT4{czE7D&QV*p@Pb(h+84n#F+?9yWBjb z#Lxg~o)Tz}1ZwfaF?k4!hY0Y<4Nm4p6GZs!QCO@yxNZTOLWtl+*b^Tg^!TFY9g7eR z51rHo94@afX3p%)zHuu1y4s_DO0A~S@a?San)=%^$21=NP>$TU=ExtMMo>MdBF&TJ ztXP;YnKUc4NLLZhl8*3@V>+x6hfc8y7sxeF&sFIb9t9~k%OHY<>EOiOWr$>HQ^%NUn8Wt~4| z!q%xKiX{ovioTK#K#+=qqXPG`c@1Sp%2Wiv=cK!z3o!XYidjv{+i>nw-C0V1|3A&x zx|_m1U9s5_OT=x3lauBgjT1cGix+L}%QqxOQ|1AJkI)P=`8BUdF6YPsPN1 zcF>~15oik>AQZu4kdRq<=@W4j39n}aLfwc62n`L9gv3@LxqFESn^Cvkh|^N)ASb}j z$TSW!&o5l8_l=3j>}sPD*QIqVenBgzxX!d|-$5;fN^?KCrOC4$OR6b09xhJAK8>0tHThZ%!>f^~OD{LU?Gl zu-8YVYBcn}KpFy2{;ef1V%69LsK;OkQ57vCAS)Q&IY&q+rwhtFQVb;C21vhnf)eYP z%cS5rWFXPz2u=(;xw}w4JBkA=S_IYt6d5n_X_}C>6cs=!*<784BZxXBl90%1-Fcr^ zmu?NJnyH98`)6T~f=?v^KqjO^DIBlj!E4!XLuC||@+-kf;n6?|MJ2ox0}g!xWWcO7 zzUF1Dd8XHnlfLtS02YX%0+hn{ zCX?UWV*K+4t;yqW*Z=E0xzhsFczK8~CuSJ72UE|4tAsi3LRq=HJm^o5?y3+U18FiH z@)lS1Dr^0|Vtl3_gf+LA$L9y$y~U3Q00l_kYPXtI_HFRIcrn-~{B`WOPb=+-n#eQN z1>4PjP@X>?YTa&O4>;`YWDORN&;!PM+x4t1Ak2D8OB!`2LRBCo@jxeyk+b2iH67Xm zP=)bJzy^>WDJTljTB{g`0!b4?y1f*>Et>DR2nS#TQk92N55aeNQRFTmf*G(zzuCv) zeldjuhA5uPaZ>oR`FS(wz-5!4NSS0ZCCyL<{2)*-(ch>xDA)AN1xj#io6(rL{2**n zvC1`Rp^>f#5q~?c&{U=fp`0(YfHf*+qioTMA`kASUnF9sK)?T&!r6xAUSWydIC+&l zXg_eP5lm3fzr<57_BeTkQD;|^$zOduCREk7b+=^}0_xt@wlz)aCOPhB^%oDxZnH{x30;SmHB&+(=J?}UaG zT69BhM-ux*j8p<$lG(Ox|MJY%Z5u9Zn>pD{*SGCEeG*JK;jT}Gel;}2IP$yJHWzD& zWOD5K?!IhS+wo==FL?7hug4Z%TG^X7&f>lvJpa+qqmK@KwC&riu9~#{uTMR5?%Xp| z+cdt}Er*1oa{=kT=c!-6kQw9IvlsvHROMyi)s~fO{cP|3)1(LRc8e(}`ks57E7h%B2!O7#bpivO7VDU|2L)2@-lFEqIQMi5>?c03!Ov zIaTZ`VIi~GLq*&pXLjzoAzmyqSJgdo>==k0JAf-)Wm8fnlk(Gmth1sA+!hUWjp?+E zTknwF(-^CWwwv@|?3Ka+eBD0Aswhj}^w?uJ-S9M9SY-M{c=!DeK-LneU3vcvvpC{z zpu4fJ^A&zq=-TGVW_CET2{*g=={{9`JUtMf?4&jo9j$#{gViCmw znp>`U6)rmbpaQ}6NuqP~cJF1b;aUgHM|i(c9aPEWq~3Suq{FRxQl?Y~ zl_oFzgihbdZN%kTojS^R(?!>W3Y!blUM8y1F>-t(09UVut>Z{-cbcWNoZ7*$RvkWr z?eMlwdBWSl&cL-6qsgJ>v=qC^L2_Y^EMOH*uM@uH#vsXoi&w9M0Za?W;d(d@XcQ6> zMwsNtBw`YZ3A)TV=rCOJYs$qsNy8)!n?&l!g94Y5P(;gez~)5fogbv~6bxgiH#ict zEwyU@9UbV+SmKkwXL-=hqm5m zU=(@jkI4aW_v(t9BU|V^pWR)=@^-C#!iIdcigGmNtIGWvlJtgxd3nK*mn60R3RQlS zgHoy8o5sVAys^-g=eN=KmaMASxaukznDPHg16OA^ATfy!!jKMBLA6K+>nFe6W}uX4 zam@%750MTw;c`Z&iE6xc5*^feH8G7=D+ikZHfl0JB4E1fkVkcn2x?>PK8<|^OdP=1 zC&hj77B5bV71xEL#ihmF-QAtyUVQQ5#l0-cvK05leG4tn0%a+-`1POM_uVCzyIdxD z^JbEnWahm|e)ID3e#)3pU2nOX+Eo?GtVu`}NJu%^n6+EtFyGZS6%xGtYZMzSycn0I`d(ki7 zRu}joD5aMQpwL`E*rS`{P1ftR zRcTC@`fwERcpd|-memlwK2q-J6$9-ypG#41u-aDaqt}hWk1^+H2_HTYg9|r7xYUnR z13Ct26`Urixq9gzCkAvGK)8zgBI!`3g`H;e1-0S4g9%@+d$Nb^vzt+J?x*jM73+gH zOZ4>WWx~*o^oCLyL!)4XdKB2N`B$zw`Co z$uJ!MqQ38m5S=4To93P79X=i1nb5au80&6hhCGwjKDJ&T6@d}3;7I@V8Mq@?ES4F@ zmXXjl><$^s-zTny?(tYkjEHc*kOLxyo|JVCG}{IN0EPN^szu)p!6qa_89hikFx2kJ z>(jhZvSfRYC#_*Jf#pfSX_T1)*)hewS#bQADGdo6LBfwloQg6^@={{rj%t}b1j!Hz zaemC^xvPvU|Mv(84qha*y)7+OW*$(J{)Jga5HX%xJYb95|FxgHI~@-ow+Q7Do8Gns zce;2@+q|mO5qs#1U}d+s?YBsi5wBU0IHeMp1BZ-P9jD+Jw%v@`N3VwdKwUqt=iqUp zwaN3|u=CDRNtQkP#lC?O91nlAV?_v(vT*aP;&g9J|{InT1#P=RzTUB)>xGI%V zV16t3Dq~U;mu*YSK&cetb)J$Wo>APORFl$Ot*+=$wU=gSqq5(nQz z?-R!|zlXBw9QUhBrX;Y9^qf~HGJAiqjeOqQJT{K2lfaTpoY&zuUn`$trf#I-^B#kL z{==WMPdg0t_#f$J=6nY0wa0$p0vV(2mOP&=lEUdub?6S{<htOIf;zd&YORK z2&xk}o3%T^I#%PMxXT;oT6W(#Gx~rRUiPK3l6!rg36y{HW4C&u9DSTAKSC<5sX ztwZXC1;S~vVWERQWk0)3>F$;y*Q zLknEDv9z_cw6r?5<;SB+Jm|iefKJb#q32arTv}c{Jv~v2QLnuPNs}rHtygjoVB0C3U|wE22JAHTeja){kim1M>DM(~Yi_ zKL+T#LKn7oOy4!mRMLR6W7g4d7y=IYOYZla`ewZ)ebDZRBSYEcH9T2 zK>Q^V1M+ndO8oVafoa_q5ZU~hv2}MXyzbTOeA&0aAp4E~M_aN;>V)Wl?50Qk%fD}y zY*S2B_nm7VSbqG-A@6Ku>g5|TQ=K_r&Zke>s9&E|3I7OrS+xE@yP*%0%r~12;^_F% zUTvH^=*#vq)vt3m>C#FdzzR_oGLno^Jdr3Mmz>r+s6i>EAv-bcYX=u_Jx$Q}M0a!+ zz&#xik~Ja5m&y4W+eeO%_9%1s8X2A14Bq$(zZR4h)J@vLN9Pswka9qNgzwE~;4v|& zSQ55O$uxeAvAnna+IlNAaeb=+BBx*7CG~DZiUQ~_hW0i(Gqk{+(hynEq_x30!}Qpk*P>7d*2-+t^LB**(WSQiExFho?Mn@m}v& z_27et9|?BDitalyaCp2{BDd^giGrR|vp^O)@!>>iw5dr0I!8*)b&!kxlUS|aXIXcu z;BGsR&Z^`(SL>exSpB`x_XZt0UoD}CsqsA;!W*el(FIyCVPqs&t8%Fa9`5l)ckw(%G)dRlok~Z7>NJeeDU-q?GAYH zV0f02{WQPbGzF>LVJU(DOxoU=-WClouJjHJz+FP;{`q%*Zir!ez>AU7(@9(=3Z~eu zPBTN?@zJ#PK2)hbzPFP;-u?V~ zyv(qEBB)ckOt+1rDfo---e=ux4;+X~X0!fR-J*PnC@8ylwX$Z@OTBtp?xpijphTZ= z&Lyo+Gz!r|bxfD0Vjc>nHew>0S%un@e({Toq_)b_*s9YHtfHaj9}l>`XGzj+0hF5+ zRhs)^OpPxxjL8luAK{UKQ^*{A*xG_!THto8G4X&RCR zCUjdBbL3yb;!57tQrDvUq&C7guf5= z;veh)8E?PQ0m&|g(Ccr_9P3ya|9EE>3ATbOeJnz6$rb=+w}b7Bfe>zaN!Pp?pcNIU4YQ^sa#Z?a|F*YTPNh zSeWcROwNh)F}an8i9M}kw9V)EY z!yaQFjgCk7eWgcu>1>)te;r}oXlb8QY-;h>Sj^oB`2bT-2>U^7vqt-+sa6OEC ziLRq5Ccu`v=ObQS(Sto(mKr+=eG)y}Id!SO5GzXM>U&F;8NzS`0*7y!p-Lm}mFkop+Alx&kwMLQ3`V4ltAiCiRjTcK)OjSKMsD{o@U#O~Qs4{#`8D645sk(osc#4M9<)-BjJvAtEt3cVhp!o58Qq7lnp zQ0TrE9MjmR=Zie;Tg2_cL4o7bV&<7K!{m{Gs#zxFizJ?uuS4I(r8Mm^!_s0S#QIYz zt{m@25zl2KY{o^?9@#C6#%|(&faD(26K?XwHH*2<@xn_5DxIV%zd!Fcw#PP}hDujz z+q2VI&skAH+ULDQ!e+%^3W_S)Gn}5c4rfI?qmzzEQz%eG8pek42jyz>&B(HsgyKmV zv1KdosLgv*pQ}}r{zMujS_s@_fLMlrw)(9c4f#0N8Ae0kW%%S*&H@Tw<5}J?wNxVH z*4u3&EWQ@fVu<{L#$jI~wYxoI7u1ex$K;n4?PYH%;dS=f%(eS|NBm>2hdRyI>Q_jA3*Tb_g3XyGGn56bl1Ci7L0zu0uA=fi0V>qPr|S? z8%f#OnuMR>{5A6@gzF_$?jrnatKLXSt@P&zuV<;eZK8SKBe3Y3qfLFs?ASM{_h}vu z%7=({-7EB@yG)Mf-Nd%52P8dvhCDhVB?9V#@~%VfrT2$J&znh0wyrAadHT3an&>(dK*6$Tc2@R}FB%g0si<6OV!mNNccs81>lCn}hPL3>mbbRFT+ybS34WoJ zl#GD!wIIQg0D8i>f~md(_k)r$p{1YuD%Ul?pf^_ zX6~E0z^wjK8m;exNay1r@Y&~9MxT-P5kW)#k2L73LJ*;F*|`*#`=o?|<$ncUgDTHx ztEVM#A_7}1w{2*7I_BTu9MqPn{-pBH7^QTr09LT8PMIVyMRP8bGHX`M%zFFz4YxbF z884Yx+a(=q*k||Tni3GLb3ftpj%PTy;m0ep#E0p-G0F0cuJUUB;}1;|O&h))^5M?z z)BRk}^TiADzVA0&y5yBSb`hPKm7d9`xJhd}wV8U`k*%EHugHjMa-AfbO4>?lndxUZ z`PWJMg-8CTT*Wp+f#F7l9TQwhss{{`FoF8eO*Or^_UR(RbK05N^ouxK_!HL=b5z^=U(y%ulZXC>UjDU(MekWzK+;TQJYH;bzk6`YJk#TkxDg@R(mv z@ce{daERf2%RGmbBRk;KZ2NOVU)9c%*;7Cc2)6k25TEXY@k*W4@^{o?e_hD?>ly}C zAR(sH*jp;^jCgd4a?B5Jhy+_+`&s%L=-Qy5L+of8rok0xgrsc0B&w~D?3^Ya95 zqKU#ZJOww=yJ2pglAF&0U}m18n;6%yFi#mNGyqH<`9=yo9cF_R3Y3t-D8ZYJb{O(O z^dhAKrNLNNHH*>IdOBO0jvSBgro`N0TY`8JR(J5MTlu6RUj9bXq)&n zG62?x*g`S{@__-{0LDlFEFLk0Bt>zC5=s-7Mry%o5DQ3Z6n7}GG{7Q~4@Qn;LkWap zLGUeNnukOYMMxf$NGJ}3U?=8u2!M!3vY`0yF~jj?VoHbj5P3*0l<+-vIDr=I6mgBj zL9yK9JrYJl4ZwB~r$_*btZl|iNjs{ zi@8xWc~hvODa>v&dS%xy5V##Fx~mZ=xElP@v9Tl)^7AU$MbG;iDC?g#S*p)}U zk&aH^wLuAmN=RdrCeFef_I!}ND5+3s2%1F#AME*_8nOx{1|hUaYla%^HXxT!G@(2Y zVvBSSsOWAHavDVy$^{|XNjrrG?DiqIPz<4b5Wr44BNVV3j~qgg-gAZ%%A}P-wRUTe z3n=P)?r>t6bPFioE;)+rULYK6Ajx8=c~2BsgyOju3C9^o-WfXG10du78HfK7Ga^Z5 zsC17HnTO)K7kgtMP8$D?pYr3o>C$P2X=RmrzpTZ$0Na0>eFCN!Uqf{(yCYT zMiV+E_`09TH0Fh-=Uy9YxH$gHD3F9}b_kxx^}*dcBu`{R;N~5oC-Qgj@D3UJw>WTF z-#7Gf@o+0&F?!i|a2;PEdii$UYJ9yqr6j`o1v=qFLy5Gs8uCL0iA2rnAZNIQu@Sk?h<al^~c9=iAP1gF~IQ+3rl_ZARw z*hy7LE^q=TCf6-EEOqcDN7y7_j@ljw^rrH4Pu@#0UKV3C;vgLRb=d}4Vk{Ez1BJ6A z)gv+(#8`?CmV75WVtg%Aeb;@a{^+h4(QRyI{<^o#ATr~pcG>jLRc&(P?Uu-0X%)Wn z?WF!8wRPShGd8JTf#p^ssDAC*Zt-KtcPmP8IoxZobtu#QEL>H^fQ}+7{Lo%BgubT1 z$4#(}BL6|?>3YF!lzP94x?uawUhuNmnEzDf)s*inHO~F!ANxjVN2BJeIW<|Avc|`k zoJtRh4YY(w_g`e(*S}f01`l8Q>6X z|4wbum_Xk^Qhen%W_e9}6GH%ZpP0Z_?y+8oQ9BobcWhAUR~Ibm2+LrJ1!~8%3=)wO zoOQR(=^4-Yi?0j7Y{LBmMnms()tsU3rmIIt6K*vhTNzvqqk;O9XBquYcXKEOZ$h zRi(M5O*L+)UNkar%8Ie@C#T|=?BEmV%j7HT^{x?lDhIj=5bZ67^s>+n z!-?0rQU@!QrqS5y=$f=u#vdtrbUqZO)8iX0ueL`(OEUPrmvZ; zSu4a)p>Bpco0)DQI#i%Wm#I1S_$cHa#lyF~p}e{G_x z%WkZ84xy(~FTLFPnYHMjzxSTmA;`y>`J}eOGYw$a9JRk$=-?JI)jv+1>0>^htI=Ud zbs}|uwcp$9P(jkoPU-rZVMKLW<&|6NSGEysjL`$c5tz|9>P_x*oy1Ysc!Hc|Q!Bce ziTAH6y_w%R#^+9R93D^~t8Tr@XSs4ula!EzZHLdy_VhRg}2h*bwb8A72kDc*srba5Y0t~p4vRq-Z=g~ z^)lLlyt8-UO!f5U<$R^!j3b{WpK14!1=G*T;83-(B0(JvRh}>V?j<%;OOqW7e}}ab zM7}kzHFWLwu|D$>NK97rjaZ%*ey7>qs0bvG?4_@vFjbJ)ut)qQ zVDgeDLQ&SZ-Ov4f2fXpOYbQzA?f9)x$&ZH_*E{co2|v)^%5iYx4Lq4}PxJFCD(Hfm zwCeIuwWI#0DnIXyjv~TkcE$L$33rB@s@1QF4L^AKyN52d@*Osp<9YUg0&t6lyhrA` z>^tdfKdYl+Gy0$9UARN^`EHQRM(3(l|07rEuMT?b^_`oDnjeM>*}ph(n%CSZepc&u z8fPnM@c0N5ZH&ui$p$An@p5ZO1G^wBgHwJ+-1j=uuZjmQ*vFFxS_3z)r*yhTcRJ+L zr+919y!)jVx}yC#%e5R4>W(2*s|p_)T;u888s0B(jgDWLnF zRw|*+A!%Mh!Q^#k$@?Lzsfc^IegX30eqnL&)RKQvw@_WLzp2lUO#TJGXi9*sySsCg z%gkgN@s{G2{!s3i-fsYo)kSrFj1NNSU_=4O{BV ziD*uO3ed6Jma8?E0ja5?C*`0X=6@;QKIlp5Vd+pR=#ebhh8$&Mt>lr@_A|{n?|S#E ze#ta60<*g;esj?PFMo6434S?ejK1|UEk{hh?F(7P|7ux{G|_J`t#Dx^v6-%ZHW%t| zm5TSal1uPvc>%xC>k0nT?N;-;|NaQx%q;1tBe2#a@rfoeTU2;1Jg=zXt3&=jRX0r% zB3U6!rixl&%=y}?kemc1Dy-`YoM;jqPAV)>JEzxh-Ksj3%Ky3{mi97nH*W*ha$6p@ zENy1I|0VROI4Hf|lg1{uQW*kHCru5xp{ zOVwHfVOdUD+*8#+16Uu~b`G*BHh>Mx_1z5bf14tdeGyFp&tbxqCs7Y>hT*zn4u1C0 zB9Z$_2G=tq@sq{-uBXD%i)y#I4b7?Y{stqQw#79K_RcEh3{>%zpQ zt2MO)?&U{q57wJ9ff_QGFc$>kl(=KR+g*VAf2sQ)pU?~Oo1D?mo*4+$ IH>08b4`|GD*#H0l diff --git a/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff2 b/docs/book/gitbook/fonts/fontawesome/fontawesome-webfont.woff2 deleted file mode 100644 index 7eb74fd127ee5eddf3b95fee6a20dc1684b0963b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 71896 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≠dR0E9ICQ{-tcR;@{R^I5P#1GUH!p=-{c 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 diff --git a/docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js b/docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js deleted file mode 100644 index ff7be7141..000000000 --- a/docs/book/gitbook/gitbook-plugin-fontsettings/fontsettings.js +++ /dev/null @@ -1,240 +0,0 @@ -require(['gitbook', 'jquery'], function(gitbook, $) { - // Configuration - var MAX_SIZE = 4, - MIN_SIZE = 0, - BUTTON_ID; - - // Current fontsettings state - var fontState; - - // Default themes - var THEMES = [ - { - config: 'white', - text: 'White', - id: 0 - }, - { - config: 'sepia', - text: 'Sepia', - id: 1 - }, - { - config: 'night', - text: 'Night', - id: 2 - } - ]; - - // Default font families - var FAMILIES = [ - { - config: 'serif', - text: 'Serif', - id: 0 - }, - { - config: 'sans', - text: 'Sans', - id: 1 - } - ]; - - // Return configured themes - function getThemes() { - return THEMES; - } - - // Modify configured themes - function setThemes(themes) { - THEMES = themes; - updateButtons(); - } - - // Return configured font families - function getFamilies() { - return FAMILIES; - } - - // Modify configured font families - function setFamilies(families) { - FAMILIES = families; - updateButtons(); - } - - // Save current font settings - function saveFontSettings() { - gitbook.storage.set('fontState', fontState); - update(); - } - - // Increase font size - function enlargeFontSize(e) { - e.preventDefault(); - if (fontState.size >= MAX_SIZE) return; - - fontState.size++; - saveFontSettings(); - } - - // Decrease font size - function reduceFontSize(e) { - e.preventDefault(); - if (fontState.size <= MIN_SIZE) return; - - fontState.size--; - saveFontSettings(); - } - - // Change font family - function changeFontFamily(configName, e) { - if (e && e instanceof Event) { - e.preventDefault(); - } - - var familyId = getFontFamilyId(configName); - fontState.family = familyId; - saveFontSettings(); - } - - // Change type of color theme - function changeColorTheme(configName, e) { - if (e && e instanceof Event) { - e.preventDefault(); - } - - var $book = gitbook.state.$book; - - // Remove currently applied color theme - if (fontState.theme !== 0) - $book.removeClass('color-theme-'+fontState.theme); - - // Set new color theme - var themeId = getThemeId(configName); - fontState.theme = themeId; - if (fontState.theme !== 0) - $book.addClass('color-theme-'+fontState.theme); - - saveFontSettings(); - } - - // Return the correct id for a font-family config key - // Default to first font-family - function getFontFamilyId(configName) { - // Search for plugin configured font family - var configFamily = $.grep(FAMILIES, function(family) { - return family.config == configName; - })[0]; - // Fallback to default font family - return (!!configFamily)? configFamily.id : 0; - } - - // Return the correct id for a theme config key - // Default to first theme - function getThemeId(configName) { - // Search for plugin configured theme - var configTheme = $.grep(THEMES, function(theme) { - return theme.config == configName; - })[0]; - // Fallback to default theme - return (!!configTheme)? configTheme.id : 0; - } - - function update() { - var $book = gitbook.state.$book; - - $('.font-settings .font-family-list li').removeClass('active'); - $('.font-settings .font-family-list li:nth-child('+(fontState.family+1)+')').addClass('active'); - - $book[0].className = $book[0].className.replace(/\bfont-\S+/g, ''); - $book.addClass('font-size-'+fontState.size); - $book.addClass('font-family-'+fontState.family); - - if(fontState.theme !== 0) { - $book[0].className = $book[0].className.replace(/\bcolor-theme-\S+/g, ''); - $book.addClass('color-theme-'+fontState.theme); - } - } - - function init(config) { - // Search for plugin configured font family - var configFamily = getFontFamilyId(config.family), - configTheme = getThemeId(config.theme); - - // Instantiate font state object - fontState = gitbook.storage.get('fontState', { - size: config.size || 2, - family: configFamily, - theme: configTheme - }); - - update(); - } - - function updateButtons() { - // Remove existing fontsettings buttons - if (!!BUTTON_ID) { - gitbook.toolbar.removeButton(BUTTON_ID); - } - - // Create buttons in toolbar - BUTTON_ID = gitbook.toolbar.createButton({ - icon: 'fa fa-font', - label: 'Font Settings', - className: 'font-settings', - dropdown: [ - [ - { - text: 'A', - className: 'font-reduce', - onClick: reduceFontSize - }, - { - text: 'A', - className: 'font-enlarge', - onClick: enlargeFontSize - } - ], - $.map(FAMILIES, function(family) { - family.onClick = function(e) { - return changeFontFamily(family.config, e); - }; - - return family; - }), - $.map(THEMES, function(theme) { - theme.onClick = function(e) { - return changeColorTheme(theme.config, e); - }; - - return theme; - }) - ] - }); - } - - // Init configuration at start - gitbook.events.bind('start', function(e, config) { - var opts = config.fontsettings; - - // Generate buttons at start - updateButtons(); - - // Init current settings - init(opts); - }); - - // Expose API - gitbook.fontsettings = { - enlargeFontSize: enlargeFontSize, - reduceFontSize: reduceFontSize, - setTheme: changeColorTheme, - setFamily: changeFontFamily, - getThemes: getThemes, - setThemes: setThemes, - getFamilies: getFamilies, - setFamilies: setFamilies - }; -}); - - diff --git a/docs/book/gitbook/gitbook-plugin-fontsettings/website.css b/docs/book/gitbook/gitbook-plugin-fontsettings/website.css deleted file mode 100644 index 26591fe81..000000000 --- a/docs/book/gitbook/gitbook-plugin-fontsettings/website.css +++ /dev/null @@ -1,291 +0,0 @@ -/* - * Theme 1 - */ -.color-theme-1 .dropdown-menu { - background-color: #111111; - border-color: #7e888b; -} -.color-theme-1 .dropdown-menu .dropdown-caret .caret-inner { - border-bottom: 9px solid #111111; -} -.color-theme-1 .dropdown-menu .buttons { - border-color: #7e888b; -} -.color-theme-1 .dropdown-menu .button { - color: #afa790; -} -.color-theme-1 .dropdown-menu .button:hover { - color: #73553c; -} -/* - * Theme 2 - */ -.color-theme-2 .dropdown-menu { - background-color: #2d3143; - border-color: #272a3a; -} -.color-theme-2 .dropdown-menu .dropdown-caret .caret-inner { - border-bottom: 9px solid #2d3143; -} -.color-theme-2 .dropdown-menu .buttons { - border-color: #272a3a; -} -.color-theme-2 .dropdown-menu .button { - color: #62677f; -} -.color-theme-2 .dropdown-menu .button:hover { - color: #f4f4f5; -} -.book .book-header .font-settings .font-enlarge { - line-height: 30px; - font-size: 1.4em; -} -.book .book-header .font-settings .font-reduce { - line-height: 30px; - font-size: 1em; -} -.book.color-theme-1 .book-body { - color: #704214; - background: #f3eacb; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section { - background: #f3eacb; -} -.book.color-theme-2 .book-body { - color: #bdcadb; - background: #1c1f2b; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section { - background: #1c1f2b; -} -.book.font-size-0 .book-body .page-inner section { - font-size: 1.2rem; -} -.book.font-size-1 .book-body .page-inner section { - font-size: 1.4rem; -} -.book.font-size-2 .book-body .page-inner section { - font-size: 1.6rem; -} -.book.font-size-3 .book-body .page-inner section { - font-size: 2.2rem; -} -.book.font-size-4 .book-body .page-inner section { - font-size: 4rem; -} -.book.font-family-0 { - font-family: Georgia, serif; -} -.book.font-family-1 { - font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal { - color: #704214; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal a { - color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h1, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h2, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h3, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h4, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h5, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h6 { - color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h1, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h2 { - border-color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal h6 { - color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal hr { - background-color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal blockquote { - border-color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code { - background: #fdf6e3; - color: #657b83; - border-color: #f8df9c; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal .highlight { - background-color: inherit; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table th, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table td { - border-color: #f5d06c; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table tr { - color: inherit; - background-color: #fdf6e3; - border-color: #444444; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal table tr:nth-child(2n) { - background-color: #fbeecb; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal { - color: #bdcadb; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal a { - color: #3eb1d0; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h1, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h2, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h3, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h4, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h5, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h6 { - color: #fffffa; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h1, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h2 { - border-color: #373b4e; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal h6 { - color: #373b4e; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal hr { - background-color: #373b4e; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal blockquote { - border-color: #373b4e; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code { - color: #9dbed8; - background: #2d3143; - border-color: #2d3143; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal .highlight { - background-color: #282a39; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table th, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table td { - border-color: #3b3f54; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table tr { - color: #b6c2d2; - background-color: #2d3143; - border-color: #3b3f54; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal table tr:nth-child(2n) { - background-color: #35394b; -} -.book.color-theme-1 .book-header { - color: #afa790; - background: transparent; -} -.book.color-theme-1 .book-header .btn { - color: #afa790; -} -.book.color-theme-1 .book-header .btn:hover { - color: #73553c; - background: none; -} -.book.color-theme-1 .book-header h1 { - color: #704214; -} -.book.color-theme-2 .book-header { - color: #7e888b; - background: transparent; -} -.book.color-theme-2 .book-header .btn { - color: #3b3f54; -} -.book.color-theme-2 .book-header .btn:hover { - color: #fffff5; - background: none; -} -.book.color-theme-2 .book-header h1 { - color: #bdcadb; -} -.book.color-theme-1 .book-body .navigation { - color: #afa790; -} -.book.color-theme-1 .book-body .navigation:hover { - color: #73553c; -} -.book.color-theme-2 .book-body .navigation { - color: #383f52; -} -.book.color-theme-2 .book-body .navigation:hover { - color: #fffff5; -} -/* - * Theme 1 - */ -.book.color-theme-1 .book-summary { - color: #afa790; - background: #111111; - border-right: 1px solid rgba(0, 0, 0, 0.07); -} -.book.color-theme-1 .book-summary .book-search { - background: transparent; -} -.book.color-theme-1 .book-summary .book-search input, -.book.color-theme-1 .book-summary .book-search input:focus { - border: 1px solid transparent; -} -.book.color-theme-1 .book-summary ul.summary li.divider { - background: #7e888b; - box-shadow: none; -} -.book.color-theme-1 .book-summary ul.summary li i.fa-check { - color: #33cc33; -} -.book.color-theme-1 .book-summary ul.summary li.done > a { - color: #877f6a; -} -.book.color-theme-1 .book-summary ul.summary li a, -.book.color-theme-1 .book-summary ul.summary li span { - color: #877f6a; - background: transparent; - font-weight: normal; -} -.book.color-theme-1 .book-summary ul.summary li.active > a, -.book.color-theme-1 .book-summary ul.summary li a:hover { - color: #704214; - background: transparent; - font-weight: normal; -} -/* - * Theme 2 - */ -.book.color-theme-2 .book-summary { - color: #bcc1d2; - background: #2d3143; - border-right: none; -} -.book.color-theme-2 .book-summary .book-search { - background: transparent; -} -.book.color-theme-2 .book-summary .book-search input, -.book.color-theme-2 .book-summary .book-search input:focus { - border: 1px solid transparent; -} -.book.color-theme-2 .book-summary ul.summary li.divider { - background: #272a3a; - box-shadow: none; -} -.book.color-theme-2 .book-summary ul.summary li i.fa-check { - color: #33cc33; -} -.book.color-theme-2 .book-summary ul.summary li.done > a { - color: #62687f; -} -.book.color-theme-2 .book-summary ul.summary li a, -.book.color-theme-2 .book-summary ul.summary li span { - color: #c1c6d7; - background: transparent; - font-weight: 600; -} -.book.color-theme-2 .book-summary ul.summary li.active > a, -.book.color-theme-2 .book-summary ul.summary li a:hover { - color: #f4f4f5; - background: #252737; - font-weight: 600; -} diff --git a/docs/book/gitbook/gitbook-plugin-highlight/ebook.css b/docs/book/gitbook/gitbook-plugin-highlight/ebook.css deleted file mode 100644 index cecaaab5a..000000000 --- a/docs/book/gitbook/gitbook-plugin-highlight/ebook.css +++ /dev/null @@ -1,135 +0,0 @@ -pre, -code { - /* http://jmblog.github.io/color-themes-for-highlightjs */ - /* Tomorrow Comment */ - /* Tomorrow Red */ - /* Tomorrow Orange */ - /* Tomorrow Yellow */ - /* Tomorrow Green */ - /* Tomorrow Aqua */ - /* Tomorrow Blue */ - /* Tomorrow Purple */ -} -pre .hljs-comment, -code .hljs-comment, -pre .hljs-title, -code .hljs-title { - color: #8e908c; -} -pre .hljs-variable, -code .hljs-variable, -pre .hljs-attribute, -code .hljs-attribute, -pre .hljs-tag, -code .hljs-tag, -pre .hljs-regexp, -code .hljs-regexp, -pre .hljs-deletion, -code .hljs-deletion, -pre .ruby .hljs-constant, -code .ruby .hljs-constant, -pre .xml .hljs-tag .hljs-title, -code .xml .hljs-tag .hljs-title, -pre .xml .hljs-pi, -code .xml .hljs-pi, -pre .xml .hljs-doctype, -code .xml .hljs-doctype, -pre .html .hljs-doctype, -code .html .hljs-doctype, -pre .css .hljs-id, -code .css .hljs-id, -pre .css .hljs-class, -code .css .hljs-class, -pre .css .hljs-pseudo, -code .css .hljs-pseudo { - color: #c82829; -} -pre .hljs-number, -code .hljs-number, -pre .hljs-preprocessor, -code .hljs-preprocessor, -pre .hljs-pragma, -code .hljs-pragma, -pre .hljs-built_in, -code .hljs-built_in, -pre .hljs-literal, -code .hljs-literal, -pre .hljs-params, -code .hljs-params, -pre .hljs-constant, -code .hljs-constant { - color: #f5871f; -} -pre .ruby .hljs-class .hljs-title, -code .ruby .hljs-class .hljs-title, -pre .css .hljs-rules .hljs-attribute, -code .css .hljs-rules .hljs-attribute { - color: #eab700; -} -pre .hljs-string, -code .hljs-string, -pre .hljs-value, -code .hljs-value, -pre .hljs-inheritance, -code .hljs-inheritance, -pre .hljs-header, -code .hljs-header, -pre .hljs-addition, -code .hljs-addition, -pre .ruby .hljs-symbol, -code .ruby .hljs-symbol, -pre .xml .hljs-cdata, -code .xml .hljs-cdata { - color: #718c00; -} -pre .css .hljs-hexcolor, -code .css .hljs-hexcolor { - color: #3e999f; -} -pre .hljs-function, -code .hljs-function, -pre .python .hljs-decorator, -code .python .hljs-decorator, -pre .python .hljs-title, -code .python .hljs-title, -pre .ruby .hljs-function .hljs-title, -code .ruby .hljs-function .hljs-title, -pre .ruby .hljs-title .hljs-keyword, -code .ruby .hljs-title .hljs-keyword, -pre .perl .hljs-sub, -code .perl .hljs-sub, -pre .javascript .hljs-title, -code .javascript .hljs-title, -pre .coffeescript .hljs-title, -code .coffeescript .hljs-title { - color: #4271ae; -} -pre .hljs-keyword, -code .hljs-keyword, -pre .javascript .hljs-function, -code .javascript .hljs-function { - color: #8959a8; -} -pre .hljs, -code .hljs { - display: block; - background: white; - color: #4d4d4c; - padding: 0.5em; -} -pre .coffeescript .javascript, -code .coffeescript .javascript, -pre .javascript .xml, -code .javascript .xml, -pre .tex .hljs-formula, -code .tex .hljs-formula, -pre .xml .javascript, -code .xml .javascript, -pre .xml .vbscript, -code .xml .vbscript, -pre .xml .css, -code .xml .css, -pre .xml .hljs-cdata, -code .xml .hljs-cdata { - opacity: 0.5; -} diff --git a/docs/book/gitbook/gitbook-plugin-highlight/website.css b/docs/book/gitbook/gitbook-plugin-highlight/website.css deleted file mode 100644 index 6674448f7..000000000 --- a/docs/book/gitbook/gitbook-plugin-highlight/website.css +++ /dev/null @@ -1,434 +0,0 @@ -.book .book-body .page-wrapper .page-inner section.normal pre, -.book .book-body .page-wrapper .page-inner section.normal code { - /* http://jmblog.github.com/color-themes-for-google-code-highlightjs */ - /* Tomorrow Comment */ - /* Tomorrow Red */ - /* Tomorrow Orange */ - /* Tomorrow Yellow */ - /* Tomorrow Green */ - /* Tomorrow Aqua */ - /* Tomorrow Blue */ - /* Tomorrow Purple */ -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-comment, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-comment, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-title { - color: #8e908c; -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-variable, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-variable, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-attribute, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-attribute, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-tag, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-tag, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-regexp, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-regexp, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-deletion, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-deletion, -.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-constant, -.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-constant, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-tag .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-tag .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-pi, -.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-pi, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-doctype, -.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-doctype, -.book .book-body .page-wrapper .page-inner section.normal pre .html .hljs-doctype, -.book .book-body .page-wrapper .page-inner section.normal code .html .hljs-doctype, -.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-id, -.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-id, -.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-class, -.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-class, -.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-pseudo, -.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-pseudo { - color: #c82829; -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-number, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-number, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-pragma, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-pragma, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-built_in, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-built_in, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-literal, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-literal, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-params, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-params, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-constant, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-constant { - color: #f5871f; -} -.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-class .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-class .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-rules .hljs-attribute, -.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-rules .hljs-attribute { - color: #eab700; -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-string, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-string, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-value, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-value, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-inheritance, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-inheritance, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-header, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-header, -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-addition, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-addition, -.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-symbol, -.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-symbol, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, -.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { - color: #718c00; -} -.book .book-body .page-wrapper .page-inner section.normal pre .css .hljs-hexcolor, -.book .book-body .page-wrapper .page-inner section.normal code .css .hljs-hexcolor { - color: #3e999f; -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-function, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-function, -.book .book-body .page-wrapper .page-inner section.normal pre .python .hljs-decorator, -.book .book-body .page-wrapper .page-inner section.normal code .python .hljs-decorator, -.book .book-body .page-wrapper .page-inner section.normal pre .python .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .python .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-function .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-function .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-title .hljs-keyword, -.book .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-title .hljs-keyword, -.book .book-body .page-wrapper .page-inner section.normal pre .perl .hljs-sub, -.book .book-body .page-wrapper .page-inner section.normal code .perl .hljs-sub, -.book .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal pre .coffeescript .hljs-title, -.book .book-body .page-wrapper .page-inner section.normal code .coffeescript .hljs-title { - color: #4271ae; -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs-keyword, -.book .book-body .page-wrapper .page-inner section.normal code .hljs-keyword, -.book .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-function, -.book .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-function { - color: #8959a8; -} -.book .book-body .page-wrapper .page-inner section.normal pre .hljs, -.book .book-body .page-wrapper .page-inner section.normal code .hljs { - display: block; - background: white; - color: #4d4d4c; - padding: 0.5em; -} -.book .book-body .page-wrapper .page-inner section.normal pre .coffeescript .javascript, -.book .book-body .page-wrapper .page-inner section.normal code .coffeescript .javascript, -.book .book-body .page-wrapper .page-inner section.normal pre .javascript .xml, -.book .book-body .page-wrapper .page-inner section.normal code .javascript .xml, -.book .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, -.book .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .javascript, -.book .book-body .page-wrapper .page-inner section.normal code .xml .javascript, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .vbscript, -.book .book-body .page-wrapper .page-inner section.normal code .xml .vbscript, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .css, -.book .book-body .page-wrapper .page-inner section.normal code .xml .css, -.book .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, -.book .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { - opacity: 0.5; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code { - /* - -Orginal Style from ethanschoonover.com/solarized (c) Jeremy Hull - -*/ - /* Solarized Green */ - /* Solarized Cyan */ - /* Solarized Blue */ - /* Solarized Yellow */ - /* Solarized Orange */ - /* Solarized Red */ - /* Solarized Violet */ -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs { - display: block; - padding: 0.5em; - background: #fdf6e3; - color: #657b83; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-comment, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-comment, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-template_comment, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-template_comment, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .diff .hljs-header, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .diff .hljs-header, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-doctype, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-doctype, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-pi, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-pi, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .lisp .hljs-string, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .lisp .hljs-string, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-javadoc, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-javadoc { - color: #93a1a1; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-keyword, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-keyword, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-winutils, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-winutils, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .method, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .method, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-addition, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-addition, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-tag, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .css .hljs-tag, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-request, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-request, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-status, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-status, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .nginx .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .nginx .hljs-title { - color: #859900; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-number, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-number, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-command, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-command, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-string, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-string, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-tag .hljs-value, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-tag .hljs-value, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-rules .hljs-value, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-rules .hljs-value, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-phpdoc, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-phpdoc, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-regexp, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-regexp, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-hexcolor, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-hexcolor, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-link_url, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-link_url { - color: #2aa198; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-localvars, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-localvars, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-chunk, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-chunk, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-decorator, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-decorator, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-built_in, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-built_in, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-identifier, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-identifier, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .vhdl .hljs-literal, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .vhdl .hljs-literal, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-id, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-id, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-function, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .css .hljs-function { - color: #268bd2; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-attribute, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-attribute, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-variable, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-variable, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .lisp .hljs-body, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .lisp .hljs-body, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .smalltalk .hljs-number, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .smalltalk .hljs-number, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-constant, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-constant, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-class .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-class .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-parent, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-parent, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .haskell .hljs-type, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .haskell .hljs-type, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-link_reference, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-link_reference { - color: #b58900; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor .hljs-keyword, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor .hljs-keyword, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-pragma, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-pragma, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-shebang, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-shebang, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-symbol, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-symbol, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-symbol .hljs-string, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-symbol .hljs-string, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .diff .hljs-change, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .diff .hljs-change, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-special, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-special, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-attr_selector, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-attr_selector, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-subst, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-subst, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-cdata, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-cdata, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .clojure .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .clojure .hljs-title, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-pseudo, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .css .hljs-pseudo, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-header, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-header { - color: #cb4b16; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-deletion, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-deletion, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-important, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-important { - color: #dc322f; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .hljs-link_label, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .hljs-link_label { - color: #6c71c4; -} -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, -.book.color-theme-1 .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula { - background: #eee8d5; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code { - /* Tomorrow Night Bright Theme */ - /* Original theme - https://github.com/chriskempson/tomorrow-theme */ - /* http://jmblog.github.com/color-themes-for-google-code-highlightjs */ - /* Tomorrow Comment */ - /* Tomorrow Red */ - /* Tomorrow Orange */ - /* Tomorrow Yellow */ - /* Tomorrow Green */ - /* Tomorrow Aqua */ - /* Tomorrow Blue */ - /* Tomorrow Purple */ -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-comment, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-comment, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-title { - color: #969896; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-variable, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-variable, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-attribute, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-attribute, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-tag, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-tag, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-regexp, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-regexp, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-deletion, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-deletion, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-constant, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-constant, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-tag .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-tag .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-pi, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-pi, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-doctype, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-doctype, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .html .hljs-doctype, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .html .hljs-doctype, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-id, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-id, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-class, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-class, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-pseudo, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-pseudo { - color: #d54e53; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-number, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-number, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-preprocessor, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-preprocessor, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-pragma, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-pragma, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-built_in, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-built_in, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-literal, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-literal, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-params, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-params, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-constant, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-constant { - color: #e78c45; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-class .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-class .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-rules .hljs-attribute, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-rules .hljs-attribute { - color: #e7c547; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-string, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-string, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-value, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-value, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-inheritance, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-inheritance, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-header, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-header, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-addition, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-addition, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-symbol, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-symbol, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { - color: #b9ca4a; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .css .hljs-hexcolor, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .css .hljs-hexcolor { - color: #70c0b1; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-function, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-function, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .python .hljs-decorator, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .python .hljs-decorator, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .python .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .python .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-function .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-function .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .ruby .hljs-title .hljs-keyword, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .ruby .hljs-title .hljs-keyword, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .perl .hljs-sub, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .perl .hljs-sub, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .coffeescript .hljs-title, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .coffeescript .hljs-title { - color: #7aa6da; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs-keyword, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs-keyword, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .javascript .hljs-function, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .javascript .hljs-function { - color: #c397d8; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .hljs, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .hljs { - display: block; - background: black; - color: #eaeaea; - padding: 0.5em; -} -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .coffeescript .javascript, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .coffeescript .javascript, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .javascript .xml, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .javascript .xml, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .tex .hljs-formula, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .tex .hljs-formula, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .javascript, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .javascript, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .vbscript, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .vbscript, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .css, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .css, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal pre .xml .hljs-cdata, -.book.color-theme-2 .book-body .page-wrapper .page-inner section.normal code .xml .hljs-cdata { - opacity: 0.5; -} diff --git a/docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js b/docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js deleted file mode 100644 index 6aa6bc7d6..000000000 --- a/docs/book/gitbook/gitbook-plugin-lunr/lunr.min.js +++ /dev/null @@ -1,7 +0,0 @@ -/** - * lunr - http://lunrjs.com - A bit like Solr, but much smaller and not as bright - 0.5.12 - * Copyright (C) 2015 Oliver Nightingale - * MIT Licensed - * @license - */ -!function(){var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.5.12",t.utils={},t.utils.warn=function(t){return function(e){t.console&&console.warn&&console.warn(e)}}(this),t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var t=Array.prototype.slice.call(arguments),e=t.pop(),n=t;if("function"!=typeof e)throw new TypeError("last argument must be a function");n.forEach(function(t){this.hasHandler(t)||(this.events[t]=[]),this.events[t].push(e)},this)},t.EventEmitter.prototype.removeListener=function(t,e){if(this.hasHandler(t)){var n=this.events[t].indexOf(e);this.events[t].splice(n,1),this.events[t].length||delete this.events[t]}},t.EventEmitter.prototype.emit=function(t){if(this.hasHandler(t)){var e=Array.prototype.slice.call(arguments,1);this.events[t].forEach(function(t){t.apply(void 0,e)})}},t.EventEmitter.prototype.hasHandler=function(t){return t in this.events},t.tokenizer=function(t){return arguments.length&&null!=t&&void 0!=t?Array.isArray(t)?t.map(function(t){return t.toLowerCase()}):t.toString().trim().toLowerCase().split(/[\s\-]+/):[]},t.Pipeline=function(){this._stack=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in this.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[e.label]=e},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.registeredFunctions[e];if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._stack.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._stack.indexOf(e);if(-1==i)throw new Error("Cannot find existingFn");i+=1,this._stack.splice(i,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._stack.indexOf(e);if(-1==i)throw new Error("Cannot find existingFn");this._stack.splice(i,0,n)},t.Pipeline.prototype.remove=function(t){var e=this._stack.indexOf(t);-1!=e&&this._stack.splice(e,1)},t.Pipeline.prototype.run=function(t){for(var e=[],n=t.length,i=this._stack.length,o=0;n>o;o++){for(var r=t[o],s=0;i>s&&(r=this._stack[s](r,o,t),void 0!==r);s++);void 0!==r&&e.push(r)}return e},t.Pipeline.prototype.reset=function(){this._stack=[]},t.Pipeline.prototype.toJSON=function(){return this._stack.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Vector=function(){this._magnitude=null,this.list=void 0,this.length=0},t.Vector.Node=function(t,e,n){this.idx=t,this.val=e,this.next=n},t.Vector.prototype.insert=function(e,n){this._magnitude=void 0;var i=this.list;if(!i)return this.list=new t.Vector.Node(e,n,i),this.length++;if(en.idx?n=n.next:(i+=e.val*n.val,e=e.next,n=n.next);return i},t.Vector.prototype.similarity=function(t){return this.dot(t)/(this.magnitude()*t.magnitude())},t.SortedSet=function(){this.length=0,this.elements=[]},t.SortedSet.load=function(t){var e=new this;return e.elements=t,e.length=t.length,e},t.SortedSet.prototype.add=function(){var t,e;for(t=0;t1;){if(r===t)return o;t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o]}return r===t?o:-1},t.SortedSet.prototype.locationFor=function(t){for(var e=0,n=this.elements.length,i=n-e,o=e+Math.floor(i/2),r=this.elements[o];i>1;)t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o];return r>t?o:t>r?o+1:void 0},t.SortedSet.prototype.intersect=function(e){for(var n=new t.SortedSet,i=0,o=0,r=this.length,s=e.length,a=this.elements,h=e.elements;;){if(i>r-1||o>s-1)break;a[i]!==h[o]?a[i]h[o]&&o++:(n.add(a[i]),i++,o++)}return n},t.SortedSet.prototype.clone=function(){var e=new t.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},t.SortedSet.prototype.union=function(t){var e,n,i;return this.length>=t.length?(e=this,n=t):(e=t,n=this),i=e.clone(),i.add.apply(i,n.toArray()),i},t.SortedSet.prototype.toJSON=function(){return this.toArray()},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.Store,this.tokenStore=new t.TokenStore,this.corpusTokens=new t.SortedSet,this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var t=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,t)},t.Index.prototype.off=function(t,e){return this.eventEmitter.removeListener(t,e)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;return n._fields=e.fields,n._ref=e.ref,n.documentStore=t.Store.load(e.documentStore),n.tokenStore=t.TokenStore.load(e.tokenStore),n.corpusTokens=t.SortedSet.load(e.corpusTokens),n.pipeline=t.Pipeline.load(e.pipeline),n},t.Index.prototype.field=function(t,e){var e=e||{},n={name:t,boost:e.boost||1};return this._fields.push(n),this},t.Index.prototype.ref=function(t){return this._ref=t,this},t.Index.prototype.add=function(e,n){var i={},o=new t.SortedSet,r=e[this._ref],n=void 0===n?!0:n;this._fields.forEach(function(n){var r=this.pipeline.run(t.tokenizer(e[n.name]));i[n.name]=r,t.SortedSet.prototype.add.apply(o,r)},this),this.documentStore.set(r,o),t.SortedSet.prototype.add.apply(this.corpusTokens,o.toArray());for(var s=0;s0&&(i=1+Math.log(this.documentStore.length/n)),this._idfCache[e]=i},t.Index.prototype.search=function(e){var n=this.pipeline.run(t.tokenizer(e)),i=new t.Vector,o=[],r=this._fields.reduce(function(t,e){return t+e.boost},0),s=n.some(function(t){return this.tokenStore.has(t)},this);if(!s)return[];n.forEach(function(e,n,s){var a=1/s.length*this._fields.length*r,h=this,l=this.tokenStore.expand(e).reduce(function(n,o){var r=h.corpusTokens.indexOf(o),s=h.idf(o),l=1,u=new t.SortedSet;if(o!==e){var c=Math.max(3,o.length-e.length);l=1/Math.log(c)}return r>-1&&i.insert(r,a*s*l),Object.keys(h.tokenStore.get(o)).forEach(function(t){u.add(t)}),n.union(u)},new t.SortedSet);o.push(l)},this);var a=o.reduce(function(t,e){return t.intersect(e)});return a.map(function(t){return{ref:t,score:i.similarity(this.documentVector(t))}},this).sort(function(t,e){return e.score-t.score})},t.Index.prototype.documentVector=function(e){for(var n=this.documentStore.get(e),i=n.length,o=new t.Vector,r=0;i>r;r++){var s=n.elements[r],a=this.tokenStore.get(s)[e].tf,h=this.idf(s);o.insert(this.corpusTokens.indexOf(s),a*h)}return o},t.Index.prototype.toJSON=function(){return{version:t.version,fields:this._fields,ref:this._ref,documentStore:this.documentStore.toJSON(),tokenStore:this.tokenStore.toJSON(),corpusTokens:this.corpusTokens.toJSON(),pipeline:this.pipeline.toJSON()}},t.Index.prototype.use=function(t){var e=Array.prototype.slice.call(arguments,1);e.unshift(this),t.apply(this,e)},t.Store=function(){this.store={},this.length=0},t.Store.load=function(e){var n=new this;return n.length=e.length,n.store=Object.keys(e.store).reduce(function(n,i){return n[i]=t.SortedSet.load(e.store[i]),n},{}),n},t.Store.prototype.set=function(t,e){this.has(t)||this.length++,this.store[t]=e},t.Store.prototype.get=function(t){return this.store[t]},t.Store.prototype.has=function(t){return t in this.store},t.Store.prototype.remove=function(t){this.has(t)&&(delete this.store[t],this.length--)},t.Store.prototype.toJSON=function(){return{store:this.store,length:this.length}},t.stemmer=function(){var t={ational:"ate",tional:"tion",enci:"ence",anci:"ance",izer:"ize",bli:"ble",alli:"al",entli:"ent",eli:"e",ousli:"ous",ization:"ize",ation:"ate",ator:"ate",alism:"al",iveness:"ive",fulness:"ful",ousness:"ous",aliti:"al",iviti:"ive",biliti:"ble",logi:"log"},e={icate:"ic",ative:"",alize:"al",iciti:"ic",ical:"ic",ful:"",ness:""},n="[^aeiou]",i="[aeiouy]",o=n+"[^aeiouy]*",r=i+"[aeiou]*",s="^("+o+")?"+r+o,a="^("+o+")?"+r+o+"("+r+")?$",h="^("+o+")?"+r+o+r+o,l="^("+o+")?"+i,u=new RegExp(s),c=new RegExp(h),f=new RegExp(a),d=new RegExp(l),p=/^(.+?)(ss|i)es$/,m=/^(.+?)([^s])s$/,v=/^(.+?)eed$/,y=/^(.+?)(ed|ing)$/,g=/.$/,S=/(at|bl|iz)$/,w=new RegExp("([^aeiouylsz])\\1$"),x=new RegExp("^"+o+i+"[^aeiouwxy]$"),k=/^(.+?[^aeiou])y$/,b=/^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/,E=/^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/,_=/^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/,F=/^(.+?)(s|t)(ion)$/,O=/^(.+?)e$/,P=/ll$/,N=new RegExp("^"+o+i+"[^aeiouwxy]$"),T=function(n){var i,o,r,s,a,h,l;if(n.length<3)return n;if(r=n.substr(0,1),"y"==r&&(n=r.toUpperCase()+n.substr(1)),s=p,a=m,s.test(n)?n=n.replace(s,"$1$2"):a.test(n)&&(n=n.replace(a,"$1$2")),s=v,a=y,s.test(n)){var T=s.exec(n);s=u,s.test(T[1])&&(s=g,n=n.replace(s,""))}else if(a.test(n)){var T=a.exec(n);i=T[1],a=d,a.test(i)&&(n=i,a=S,h=w,l=x,a.test(n)?n+="e":h.test(n)?(s=g,n=n.replace(s,"")):l.test(n)&&(n+="e"))}if(s=k,s.test(n)){var T=s.exec(n);i=T[1],n=i+"i"}if(s=b,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+t[o])}if(s=E,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+e[o])}if(s=_,a=F,s.test(n)){var T=s.exec(n);i=T[1],s=c,s.test(i)&&(n=i)}else if(a.test(n)){var T=a.exec(n);i=T[1]+T[2],a=c,a.test(i)&&(n=i)}if(s=O,s.test(n)){var T=s.exec(n);i=T[1],s=c,a=f,h=N,(s.test(i)||a.test(i)&&!h.test(i))&&(n=i)}return s=P,a=c,s.test(n)&&a.test(n)&&(s=g,n=n.replace(s,"")),"y"==r&&(n=r.toLowerCase()+n.substr(1)),n};return T}(),t.Pipeline.registerFunction(t.stemmer,"stemmer"),t.stopWordFilter=function(e){return e&&t.stopWordFilter.stopWords[e]!==e?e:void 0},t.stopWordFilter.stopWords={a:"a",able:"able",about:"about",across:"across",after:"after",all:"all",almost:"almost",also:"also",am:"am",among:"among",an:"an",and:"and",any:"any",are:"are",as:"as",at:"at",be:"be",because:"because",been:"been",but:"but",by:"by",can:"can",cannot:"cannot",could:"could",dear:"dear",did:"did","do":"do",does:"does",either:"either","else":"else",ever:"ever",every:"every","for":"for",from:"from",get:"get",got:"got",had:"had",has:"has",have:"have",he:"he",her:"her",hers:"hers",him:"him",his:"his",how:"how",however:"however",i:"i","if":"if","in":"in",into:"into",is:"is",it:"it",its:"its",just:"just",least:"least",let:"let",like:"like",likely:"likely",may:"may",me:"me",might:"might",most:"most",must:"must",my:"my",neither:"neither",no:"no",nor:"nor",not:"not",of:"of",off:"off",often:"often",on:"on",only:"only",or:"or",other:"other",our:"our",own:"own",rather:"rather",said:"said",say:"say",says:"says",she:"she",should:"should",since:"since",so:"so",some:"some",than:"than",that:"that",the:"the",their:"their",them:"them",then:"then",there:"there",these:"these",they:"they","this":"this",tis:"tis",to:"to",too:"too",twas:"twas",us:"us",wants:"wants",was:"was",we:"we",were:"were",what:"what",when:"when",where:"where",which:"which","while":"while",who:"who",whom:"whom",why:"why",will:"will","with":"with",would:"would",yet:"yet",you:"you",your:"your"},t.Pipeline.registerFunction(t.stopWordFilter,"stopWordFilter"),t.trimmer=function(t){var e=t.replace(/^\W+/,"").replace(/\W+$/,"");return""===e?void 0:e},t.Pipeline.registerFunction(t.trimmer,"trimmer"),t.TokenStore=function(){this.root={docs:{}},this.length=0},t.TokenStore.load=function(t){var e=new this;return e.root=t.root,e.length=t.length,e},t.TokenStore.prototype.add=function(t,e,n){var n=n||this.root,i=t[0],o=t.slice(1);return i in n||(n[i]={docs:{}}),0===o.length?(n[i].docs[e.ref]=e,void(this.length+=1)):this.add(o,e,n[i])},t.TokenStore.prototype.has=function(t){if(!t)return!1;for(var e=this.root,n=0;no;o++){for(var r=t[o],s=0;i>s&&(r=this._stack[s](r,o,t),void 0!==r);s++);void 0!==r&&e.push(r)}return e},t.Pipeline.prototype.reset=function(){this._stack=[]},t.Pipeline.prototype.toJSON=function(){return this._stack.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Vector=function(){this._magnitude=null,this.list=void 0,this.length=0},t.Vector.Node=function(t,e,n){this.idx=t,this.val=e,this.next=n},t.Vector.prototype.insert=function(e,n){this._magnitude=void 0;var i=this.list;if(!i)return this.list=new t.Vector.Node(e,n,i),this.length++;if(en.idx?n=n.next:(i+=e.val*n.val,e=e.next,n=n.next);return i},t.Vector.prototype.similarity=function(t){return this.dot(t)/(this.magnitude()*t.magnitude())},t.SortedSet=function(){this.length=0,this.elements=[]},t.SortedSet.load=function(t){var e=new this;return e.elements=t,e.length=t.length,e},t.SortedSet.prototype.add=function(){var t,e;for(t=0;t1;){if(r===t)return o;t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o]}return r===t?o:-1},t.SortedSet.prototype.locationFor=function(t){for(var e=0,n=this.elements.length,i=n-e,o=e+Math.floor(i/2),r=this.elements[o];i>1;)t>r&&(e=o),r>t&&(n=o),i=n-e,o=e+Math.floor(i/2),r=this.elements[o];return r>t?o:t>r?o+1:void 0},t.SortedSet.prototype.intersect=function(e){for(var n=new t.SortedSet,i=0,o=0,r=this.length,s=e.length,a=this.elements,h=e.elements;;){if(i>r-1||o>s-1)break;a[i]!==h[o]?a[i]h[o]&&o++:(n.add(a[i]),i++,o++)}return n},t.SortedSet.prototype.clone=function(){var e=new t.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},t.SortedSet.prototype.union=function(t){var e,n,i;return this.length>=t.length?(e=this,n=t):(e=t,n=this),i=e.clone(),i.add.apply(i,n.toArray()),i},t.SortedSet.prototype.toJSON=function(){return this.toArray()},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.Store,this.tokenStore=new t.TokenStore,this.corpusTokens=new t.SortedSet,this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var t=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,t)},t.Index.prototype.off=function(t,e){return this.eventEmitter.removeListener(t,e)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;return n._fields=e.fields,n._ref=e.ref,n.documentStore=t.Store.load(e.documentStore),n.tokenStore=t.TokenStore.load(e.tokenStore),n.corpusTokens=t.SortedSet.load(e.corpusTokens),n.pipeline=t.Pipeline.load(e.pipeline),n},t.Index.prototype.field=function(t,e){var e=e||{},n={name:t,boost:e.boost||1};return this._fields.push(n),this},t.Index.prototype.ref=function(t){return this._ref=t,this},t.Index.prototype.add=function(e,n){var i={},o=new t.SortedSet,r=e[this._ref],n=void 0===n?!0:n;this._fields.forEach(function(n){var r=this.pipeline.run(t.tokenizer(e[n.name]));i[n.name]=r,t.SortedSet.prototype.add.apply(o,r)},this),this.documentStore.set(r,o),t.SortedSet.prototype.add.apply(this.corpusTokens,o.toArray());for(var s=0;s0&&(i=1+Math.log(this.documentStore.length/n)),this._idfCache[e]=i},t.Index.prototype.search=function(e){var n=this.pipeline.run(t.tokenizer(e)),i=new t.Vector,o=[],r=this._fields.reduce(function(t,e){return t+e.boost},0),s=n.some(function(t){return this.tokenStore.has(t)},this);if(!s)return[];n.forEach(function(e,n,s){var a=1/s.length*this._fields.length*r,h=this,l=this.tokenStore.expand(e).reduce(function(n,o){var r=h.corpusTokens.indexOf(o),s=h.idf(o),l=1,u=new t.SortedSet;if(o!==e){var c=Math.max(3,o.length-e.length);l=1/Math.log(c)}return r>-1&&i.insert(r,a*s*l),Object.keys(h.tokenStore.get(o)).forEach(function(t){u.add(t)}),n.union(u)},new t.SortedSet);o.push(l)},this);var a=o.reduce(function(t,e){return t.intersect(e)});return a.map(function(t){return{ref:t,score:i.similarity(this.documentVector(t))}},this).sort(function(t,e){return e.score-t.score})},t.Index.prototype.documentVector=function(e){for(var n=this.documentStore.get(e),i=n.length,o=new t.Vector,r=0;i>r;r++){var s=n.elements[r],a=this.tokenStore.get(s)[e].tf,h=this.idf(s);o.insert(this.corpusTokens.indexOf(s),a*h)}return o},t.Index.prototype.toJSON=function(){return{version:t.version,fields:this._fields,ref:this._ref,documentStore:this.documentStore.toJSON(),tokenStore:this.tokenStore.toJSON(),corpusTokens:this.corpusTokens.toJSON(),pipeline:this.pipeline.toJSON()}},t.Index.prototype.use=function(t){var e=Array.prototype.slice.call(arguments,1);e.unshift(this),t.apply(this,e)},t.Store=function(){this.store={},this.length=0},t.Store.load=function(e){var n=new this;return n.length=e.length,n.store=Object.keys(e.store).reduce(function(n,i){return n[i]=t.SortedSet.load(e.store[i]),n},{}),n},t.Store.prototype.set=function(t,e){this.has(t)||this.length++,this.store[t]=e},t.Store.prototype.get=function(t){return this.store[t]},t.Store.prototype.has=function(t){return t in this.store},t.Store.prototype.remove=function(t){this.has(t)&&(delete this.store[t],this.length--)},t.Store.prototype.toJSON=function(){return{store:this.store,length:this.length}},t.stemmer=function(){var t={ational:"ate",tional:"tion",enci:"ence",anci:"ance",izer:"ize",bli:"ble",alli:"al",entli:"ent",eli:"e",ousli:"ous",ization:"ize",ation:"ate",ator:"ate",alism:"al",iveness:"ive",fulness:"ful",ousness:"ous",aliti:"al",iviti:"ive",biliti:"ble",logi:"log"},e={icate:"ic",ative:"",alize:"al",iciti:"ic",ical:"ic",ful:"",ness:""},n="[^aeiou]",i="[aeiouy]",o=n+"[^aeiouy]*",r=i+"[aeiou]*",s="^("+o+")?"+r+o,a="^("+o+")?"+r+o+"("+r+")?$",h="^("+o+")?"+r+o+r+o,l="^("+o+")?"+i,u=new RegExp(s),c=new RegExp(h),f=new RegExp(a),d=new RegExp(l),p=/^(.+?)(ss|i)es$/,m=/^(.+?)([^s])s$/,v=/^(.+?)eed$/,y=/^(.+?)(ed|ing)$/,g=/.$/,S=/(at|bl|iz)$/,w=new RegExp("([^aeiouylsz])\\1$"),x=new RegExp("^"+o+i+"[^aeiouwxy]$"),k=/^(.+?[^aeiou])y$/,b=/^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/,E=/^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/,_=/^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/,F=/^(.+?)(s|t)(ion)$/,O=/^(.+?)e$/,P=/ll$/,N=new RegExp("^"+o+i+"[^aeiouwxy]$"),T=function(n){var i,o,r,s,a,h,l;if(n.length<3)return n;if(r=n.substr(0,1),"y"==r&&(n=r.toUpperCase()+n.substr(1)),s=p,a=m,s.test(n)?n=n.replace(s,"$1$2"):a.test(n)&&(n=n.replace(a,"$1$2")),s=v,a=y,s.test(n)){var T=s.exec(n);s=u,s.test(T[1])&&(s=g,n=n.replace(s,""))}else if(a.test(n)){var T=a.exec(n);i=T[1],a=d,a.test(i)&&(n=i,a=S,h=w,l=x,a.test(n)?n+="e":h.test(n)?(s=g,n=n.replace(s,"")):l.test(n)&&(n+="e"))}if(s=k,s.test(n)){var T=s.exec(n);i=T[1],n=i+"i"}if(s=b,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+t[o])}if(s=E,s.test(n)){var T=s.exec(n);i=T[1],o=T[2],s=u,s.test(i)&&(n=i+e[o])}if(s=_,a=F,s.test(n)){var T=s.exec(n);i=T[1],s=c,s.test(i)&&(n=i)}else if(a.test(n)){var T=a.exec(n);i=T[1]+T[2],a=c,a.test(i)&&(n=i)}if(s=O,s.test(n)){var T=s.exec(n);i=T[1],s=c,a=f,h=N,(s.test(i)||a.test(i)&&!h.test(i))&&(n=i)}return s=P,a=c,s.test(n)&&a.test(n)&&(s=g,n=n.replace(s,"")),"y"==r&&(n=r.toLowerCase()+n.substr(1)),n};return T}(),t.Pipeline.registerFunction(t.stemmer,"stemmer"),t.stopWordFilter=function(e){return e&&t.stopWordFilter.stopWords[e]!==e?e:void 0},t.stopWordFilter.stopWords={a:"a",able:"able",about:"about",across:"across",after:"after",all:"all",almost:"almost",also:"also",am:"am",among:"among",an:"an",and:"and",any:"any",are:"are",as:"as",at:"at",be:"be",because:"because",been:"been",but:"but",by:"by",can:"can",cannot:"cannot",could:"could",dear:"dear",did:"did","do":"do",does:"does",either:"either","else":"else",ever:"ever",every:"every","for":"for",from:"from",get:"get",got:"got",had:"had",has:"has",have:"have",he:"he",her:"her",hers:"hers",him:"him",his:"his",how:"how",however:"however",i:"i","if":"if","in":"in",into:"into",is:"is",it:"it",its:"its",just:"just",least:"least",let:"let",like:"like",likely:"likely",may:"may",me:"me",might:"might",most:"most",must:"must",my:"my",neither:"neither",no:"no",nor:"nor",not:"not",of:"of",off:"off",often:"often",on:"on",only:"only",or:"or",other:"other",our:"our",own:"own",rather:"rather",said:"said",say:"say",says:"says",she:"she",should:"should",since:"since",so:"so",some:"some",than:"than",that:"that",the:"the",their:"their",them:"them",then:"then",there:"there",these:"these",they:"they","this":"this",tis:"tis",to:"to",too:"too",twas:"twas",us:"us",wants:"wants",was:"was",we:"we",were:"were",what:"what",when:"when",where:"where",which:"which","while":"while",who:"who",whom:"whom",why:"why",will:"will","with":"with",would:"would",yet:"yet",you:"you",your:"your"},t.Pipeline.registerFunction(t.stopWordFilter,"stopWordFilter"),t.trimmer=function(t){var e=t.replace(/^\W+/,"").replace(/\W+$/,"");return""===e?void 0:e},t.Pipeline.registerFunction(t.trimmer,"trimmer"),t.TokenStore=function(){this.root={docs:{}},this.length=0},t.TokenStore.load=function(t){var e=new this;return e.root=t.root,e.length=t.length,e},t.TokenStore.prototype.add=function(t,e,n){var n=n||this.root,i=t[0],o=t.slice(1);return i in n||(n[i]={docs:{}}),0===o.length?(n[i].docs[e.ref]=e,void(this.length+=1)):this.add(o,e,n[i])},t.TokenStore.prototype.has=function(t){if(!t)return!1;for(var e=this.root,n=0;n element for each result - res.results.forEach(function(res) { - var $li = $('

                            • ', { - 'class': 'search-results-item' - }); - - var $title = $('

                              '); - - var $link = $('', { - 'href': gitbook.state.basePath + '/' + res.url, - 'text': res.title - }); - - var content = res.body.trim(); - if (content.length > MAX_DESCRIPTION_SIZE) { - content = content.slice(0, MAX_DESCRIPTION_SIZE).trim()+'...'; - } - var $content = $('

                              ').html(content); - - $link.appendTo($title); - $title.appendTo($li); - $content.appendTo($li); - $li.appendTo($searchList); - }); - } - - function launchSearch(q) { - // Add class for loading - $body.addClass('with-search'); - $body.addClass('search-loading'); - - // Launch search query - throttle(gitbook.search.query(q, 0, MAX_RESULTS) - .then(function(results) { - displayResults(results); - }) - .always(function() { - $body.removeClass('search-loading'); - }), 1000); - } - - function closeSearch() { - $body.removeClass('with-search'); - $bookSearchResults.removeClass('open'); - } - - function launchSearchFromQueryString() { - var q = getParameterByName('q'); - if (q && q.length > 0) { - // Update search input - $searchInput.val(q); - - // Launch search - launchSearch(q); - } - } - - function bindSearch() { - // Bind DOM - $searchInput = $('#book-search-input input'); - $bookSearchResults = $('#book-search-results'); - $searchList = $bookSearchResults.find('.search-results-list'); - $searchTitle = $bookSearchResults.find('.search-results-title'); - $searchResultsCount = $searchTitle.find('.search-results-count'); - $searchQuery = $searchTitle.find('.search-query'); - - // Launch query based on input content - function handleUpdate() { - var q = $searchInput.val(); - - if (q.length == 0) { - closeSearch(); - } - else { - launchSearch(q); - } - } - - // Detect true content change in search input - // Workaround for IE < 9 - var propertyChangeUnbound = false; - $searchInput.on('propertychange', function(e) { - if (e.originalEvent.propertyName == 'value') { - handleUpdate(); - } - }); - - // HTML5 (IE9 & others) - $searchInput.on('input', function(e) { - // Unbind propertychange event for IE9+ - if (!propertyChangeUnbound) { - $(this).unbind('propertychange'); - propertyChangeUnbound = true; - } - - handleUpdate(); - }); - - // Push to history on blur - $searchInput.on('blur', function(e) { - // Update history state - if (usePushState) { - var uri = updateQueryString('q', $(this).val()); - history.pushState({ path: uri }, null, uri); - } - }); - } - - gitbook.events.on('page.change', function() { - bindSearch(); - closeSearch(); - - // Launch search based on query parameter - if (gitbook.search.isInitialized()) { - launchSearchFromQueryString(); - } - }); - - gitbook.events.on('search.ready', function() { - bindSearch(); - - // Launch search from query param at start - launchSearchFromQueryString(); - }); - - function getParameterByName(name) { - var url = window.location.href; - name = name.replace(/[\[\]]/g, '\\$&'); - var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)', 'i'), - results = regex.exec(url); - if (!results) return null; - if (!results[2]) return ''; - return decodeURIComponent(results[2].replace(/\+/g, ' ')); - } - - function updateQueryString(key, value) { - value = encodeURIComponent(value); - - var url = window.location.href; - var re = new RegExp('([?&])' + key + '=.*?(&|#|$)(.*)', 'gi'), - hash; - - if (re.test(url)) { - if (typeof value !== 'undefined' && value !== null) - return url.replace(re, '$1' + key + '=' + value + '$2$3'); - else { - hash = url.split('#'); - url = hash[0].replace(re, '$1$3').replace(/(&|\?)$/, ''); - if (typeof hash[1] !== 'undefined' && hash[1] !== null) - url += '#' + hash[1]; - return url; - } - } - else { - if (typeof value !== 'undefined' && value !== null) { - var separator = url.indexOf('?') !== -1 ? '&' : '?'; - hash = url.split('#'); - url = hash[0] + separator + key + '=' + value; - if (typeof hash[1] !== 'undefined' && hash[1] !== null) - url += '#' + hash[1]; - return url; - } - else - return url; - } - } -}); diff --git a/docs/book/gitbook/gitbook-plugin-sharing/buttons.js b/docs/book/gitbook/gitbook-plugin-sharing/buttons.js deleted file mode 100644 index 709a4e4c0..000000000 --- a/docs/book/gitbook/gitbook-plugin-sharing/buttons.js +++ /dev/null @@ -1,90 +0,0 @@ -require(['gitbook', 'jquery'], function(gitbook, $) { - var SITES = { - 'facebook': { - 'label': 'Facebook', - 'icon': 'fa fa-facebook', - 'onClick': function(e) { - e.preventDefault(); - window.open('http://www.facebook.com/sharer/sharer.php?s=100&p[url]='+encodeURIComponent(location.href)); - } - }, - 'twitter': { - 'label': 'Twitter', - 'icon': 'fa fa-twitter', - 'onClick': function(e) { - e.preventDefault(); - window.open('http://twitter.com/home?status='+encodeURIComponent(document.title+' '+location.href)); - } - }, - 'google': { - 'label': 'Google+', - 'icon': 'fa fa-google-plus', - 'onClick': function(e) { - e.preventDefault(); - window.open('https://plus.google.com/share?url='+encodeURIComponent(location.href)); - } - }, - 'weibo': { - 'label': 'Weibo', - 'icon': 'fa fa-weibo', - 'onClick': function(e) { - e.preventDefault(); - window.open('http://service.weibo.com/share/share.php?content=utf-8&url='+encodeURIComponent(location.href)+'&title='+encodeURIComponent(document.title)); - } - }, - 'instapaper': { - 'label': 'Instapaper', - 'icon': 'fa fa-instapaper', - 'onClick': function(e) { - e.preventDefault(); - window.open('http://www.instapaper.com/text?u='+encodeURIComponent(location.href)); - } - }, - 'vk': { - 'label': 'VK', - 'icon': 'fa fa-vk', - 'onClick': function(e) { - e.preventDefault(); - window.open('http://vkontakte.ru/share.php?url='+encodeURIComponent(location.href)); - } - } - }; - - - - gitbook.events.bind('start', function(e, config) { - var opts = config.sharing; - - // Create dropdown menu - var menu = $.map(opts.all, function(id) { - var site = SITES[id]; - - return { - text: site.label, - onClick: site.onClick - }; - }); - - // Create main button with dropdown - if (menu.length > 0) { - gitbook.toolbar.createButton({ - icon: 'fa fa-share-alt', - label: 'Share', - position: 'right', - dropdown: [menu] - }); - } - - // Direct actions to share - $.each(SITES, function(sideId, site) { - if (!opts[sideId]) return; - - gitbook.toolbar.createButton({ - icon: site.icon, - label: site.text, - position: 'right', - onClick: site.onClick - }); - }); - }); -}); diff --git a/docs/book/gitbook/gitbook.js b/docs/book/gitbook/gitbook.js deleted file mode 100644 index 10000c790..000000000 --- a/docs/book/gitbook/gitbook.js +++ /dev/null @@ -1,4 +0,0 @@ -!function e(t,n,r){function o(s,a){if(!n[s]){if(!t[s]){var u="function"==typeof require&&require;if(!a&&u)return u(s,!0);if(i)return i(s,!0);var c=new Error("Cannot find module '"+s+"'");throw c.code="MODULE_NOT_FOUND",c}var l=n[s]={exports:{}};t[s][0].call(l.exports,function(e){var n=t[s][1][e];return o(n?n:e)},l,l.exports,e,t,n,r)}return n[s].exports}for(var i="function"==typeof require&&require,s=0;s0&&t-1 in e)}function o(e,t,n){return de.isFunction(t)?de.grep(e,function(e,r){return!!t.call(e,r,e)!==n}):t.nodeType?de.grep(e,function(e){return e===t!==n}):"string"!=typeof t?de.grep(e,function(e){return se.call(t,e)>-1!==n}):je.test(t)?de.filter(t,e,n):(t=de.filter(t,e),de.grep(e,function(e){return se.call(t,e)>-1!==n&&1===e.nodeType}))}function i(e,t){for(;(e=e[t])&&1!==e.nodeType;);return e}function s(e){var t={};return de.each(e.match(qe)||[],function(e,n){t[n]=!0}),t}function a(e){return e}function u(e){throw e}function c(e,t,n){var r;try{e&&de.isFunction(r=e.promise)?r.call(e).done(t).fail(n):e&&de.isFunction(r=e.then)?r.call(e,t,n):t.call(void 0,e)}catch(e){n.call(void 0,e)}}function l(){te.removeEventListener("DOMContentLoaded",l),e.removeEventListener("load",l),de.ready()}function f(){this.expando=de.expando+f.uid++}function p(e){return"true"===e||"false"!==e&&("null"===e?null:e===+e+""?+e:Ie.test(e)?JSON.parse(e):e)}function h(e,t,n){var r;if(void 0===n&&1===e.nodeType)if(r="data-"+t.replace(Pe,"-$&").toLowerCase(),n=e.getAttribute(r),"string"==typeof n){try{n=p(n)}catch(e){}Re.set(e,t,n)}else n=void 0;return n}function d(e,t,n,r){var o,i=1,s=20,a=r?function(){return r.cur()}:function(){return de.css(e,t,"")},u=a(),c=n&&n[3]||(de.cssNumber[t]?"":"px"),l=(de.cssNumber[t]||"px"!==c&&+u)&&$e.exec(de.css(e,t));if(l&&l[3]!==c){c=c||l[3],n=n||[],l=+u||1;do i=i||".5",l/=i,de.style(e,t,l+c);while(i!==(i=a()/u)&&1!==i&&--s)}return n&&(l=+l||+u||0,o=n[1]?l+(n[1]+1)*n[2]:+n[2],r&&(r.unit=c,r.start=l,r.end=o)),o}function g(e){var t,n=e.ownerDocument,r=e.nodeName,o=Ue[r];return o?o:(t=n.body.appendChild(n.createElement(r)),o=de.css(t,"display"),t.parentNode.removeChild(t),"none"===o&&(o="block"),Ue[r]=o,o)}function m(e,t){for(var n,r,o=[],i=0,s=e.length;i-1)o&&o.push(i);else if(c=de.contains(i.ownerDocument,i),s=v(f.appendChild(i),"script"),c&&y(s),n)for(l=0;i=s[l++];)Ve.test(i.type||"")&&n.push(i);return f}function b(){return!0}function w(){return!1}function T(){try{return te.activeElement}catch(e){}}function C(e,t,n,r,o,i){var s,a;if("object"==typeof t){"string"!=typeof n&&(r=r||n,n=void 0);for(a in t)C(e,a,n,r,t[a],i);return e}if(null==r&&null==o?(o=n,r=n=void 0):null==o&&("string"==typeof n?(o=r,r=void 0):(o=r,r=n,n=void 0)),o===!1)o=w;else if(!o)return e;return 1===i&&(s=o,o=function(e){return de().off(e),s.apply(this,arguments)},o.guid=s.guid||(s.guid=de.guid++)),e.each(function(){de.event.add(this,t,o,r,n)})}function j(e,t){return de.nodeName(e,"table")&&de.nodeName(11!==t.nodeType?t:t.firstChild,"tr")?e.getElementsByTagName("tbody")[0]||e:e}function k(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function E(e){var t=rt.exec(e.type);return t?e.type=t[1]:e.removeAttribute("type"),e}function S(e,t){var n,r,o,i,s,a,u,c;if(1===t.nodeType){if(Fe.hasData(e)&&(i=Fe.access(e),s=Fe.set(t,i),c=i.events)){delete s.handle,s.events={};for(o in c)for(n=0,r=c[o].length;n1&&"string"==typeof d&&!pe.checkClone&&nt.test(d))return e.each(function(n){var i=e.eq(n);g&&(t[0]=d.call(this,n,i.html())),A(i,t,r,o)});if(p&&(i=x(t,e[0].ownerDocument,!1,e,o),s=i.firstChild,1===i.childNodes.length&&(i=s),s||o)){for(a=de.map(v(i,"script"),k),u=a.length;f=0&&nC.cacheLength&&delete e[t.shift()],e[n+" "]=r}var t=[];return e}function r(e){return e[$]=!0,e}function o(e){var t=L.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function i(e,t){for(var n=e.split("|"),r=n.length;r--;)C.attrHandle[n[r]]=t}function s(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)for(;n=n.nextSibling;)if(n===t)return-1;return e?1:-1}function a(e){return function(t){var n=t.nodeName.toLowerCase();return"input"===n&&t.type===e}}function u(e){return function(t){var n=t.nodeName.toLowerCase();return("input"===n||"button"===n)&&t.type===e}}function c(e){return function(t){return"form"in t?t.parentNode&&t.disabled===!1?"label"in t?"label"in t.parentNode?t.parentNode.disabled===e:t.disabled===e:t.isDisabled===e||t.isDisabled!==!e&&je(t)===e:t.disabled===e:"label"in t&&t.disabled===e}}function l(e){return r(function(t){return t=+t,r(function(n,r){for(var o,i=e([],n.length,t),s=i.length;s--;)n[o=i[s]]&&(n[o]=!(r[o]=n[o]))})})}function f(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}function p(){}function h(e){for(var t=0,n=e.length,r="";t1?function(t,n,r){for(var o=e.length;o--;)if(!e[o](t,n,r))return!1;return!0}:e[0]}function m(e,n,r){for(var o=0,i=n.length;o-1&&(r[c]=!(s[c]=f))}}else x=v(x===s?x.splice(d,x.length):x),i?i(null,s,x,u):K.apply(s,x)})}function x(e){for(var t,n,r,o=e.length,i=C.relative[e[0].type],s=i||C.relative[" "],a=i?1:0,u=d(function(e){return e===t},s,!0),c=d(function(e){return ee(t,e)>-1},s,!0),l=[function(e,n,r){var o=!i&&(r||n!==A)||((t=n).nodeType?u(e,n,r):c(e,n,r));return t=null,o}];a1&&g(l),a>1&&h(e.slice(0,a-1).concat({value:" "===e[a-2].type?"*":""})).replace(ae,"$1"),n,a0,i=e.length>0,s=function(r,s,a,u,c){var l,f,p,h=0,d="0",g=r&&[],m=[],y=A,x=r||i&&C.find.TAG("*",c),b=B+=null==y?1:Math.random()||.1,w=x.length;for(c&&(A=s===L||s||c);d!==w&&null!=(l=x[d]);d++){if(i&&l){for(f=0,s||l.ownerDocument===L||(O(l),a=!F);p=e[f++];)if(p(l,s||L,a)){u.push(l);break}c&&(B=b)}o&&((l=!p&&l)&&h--,r&&g.push(l))}if(h+=d,o&&d!==h){for(f=0;p=n[f++];)p(g,m,s,a);if(r){if(h>0)for(;d--;)g[d]||m[d]||(m[d]=Q.call(u));m=v(m)}K.apply(u,m),c&&!r&&m.length>0&&h+n.length>1&&t.uniqueSort(u)}return c&&(B=b,A=y),g};return o?r(s):s}var w,T,C,j,k,E,S,N,A,q,D,O,L,H,F,R,I,P,M,$="sizzle"+1*new Date,W=e.document,B=0,_=0,U=n(),z=n(),X=n(),V=function(e,t){return e===t&&(D=!0),0},G={}.hasOwnProperty,Y=[],Q=Y.pop,J=Y.push,K=Y.push,Z=Y.slice,ee=function(e,t){for(var n=0,r=e.length;n+~]|"+ne+")"+ne+"*"),le=new RegExp("="+ne+"*([^\\]'\"]*?)"+ne+"*\\]","g"),fe=new RegExp(ie),pe=new RegExp("^"+re+"$"),he={ID:new RegExp("^#("+re+")"),CLASS:new RegExp("^\\.("+re+")"),TAG:new RegExp("^("+re+"|[*])"),ATTR:new RegExp("^"+oe),PSEUDO:new RegExp("^"+ie),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+ne+"*(even|odd|(([+-]|)(\\d*)n|)"+ne+"*(?:([+-]|)"+ne+"*(\\d+)|))"+ne+"*\\)|)","i"),bool:new RegExp("^(?:"+te+")$","i"),needsContext:new RegExp("^"+ne+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+ne+"*((?:-\\d)?\\d*)"+ne+"*\\)|)(?=[^-]|$)","i")},de=/^(?:input|select|textarea|button)$/i,ge=/^h\d$/i,me=/^[^{]+\{\s*\[native \w/,ve=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ye=/[+~]/,xe=new RegExp("\\\\([\\da-f]{1,6}"+ne+"?|("+ne+")|.)","ig"),be=function(e,t,n){var r="0x"+t-65536;return r!==r||n?t:r<0?String.fromCharCode(r+65536):String.fromCharCode(r>>10|55296,1023&r|56320)},we=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,Te=function(e,t){return t?"\0"===e?"�":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},Ce=function(){O()},je=d(function(e){return e.disabled===!0&&("form"in e||"label"in e)},{dir:"parentNode",next:"legend"});try{K.apply(Y=Z.call(W.childNodes),W.childNodes),Y[W.childNodes.length].nodeType}catch(e){K={apply:Y.length?function(e,t){J.apply(e,Z.call(t))}:function(e,t){for(var n=e.length,r=0;e[n++]=t[r++];);e.length=n-1}}}T=t.support={},k=t.isXML=function(e){var t=e&&(e.ownerDocument||e).documentElement;return!!t&&"HTML"!==t.nodeName},O=t.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:W;return r!==L&&9===r.nodeType&&r.documentElement?(L=r,H=L.documentElement,F=!k(L),W!==L&&(n=L.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",Ce,!1):n.attachEvent&&n.attachEvent("onunload",Ce)),T.attributes=o(function(e){return e.className="i",!e.getAttribute("className")}),T.getElementsByTagName=o(function(e){return e.appendChild(L.createComment("")),!e.getElementsByTagName("*").length}),T.getElementsByClassName=me.test(L.getElementsByClassName),T.getById=o(function(e){return H.appendChild(e).id=$,!L.getElementsByName||!L.getElementsByName($).length}),T.getById?(C.filter.ID=function(e){var t=e.replace(xe,be);return function(e){return e.getAttribute("id")===t}},C.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&F){var n=t.getElementById(e);return n?[n]:[]}}):(C.filter.ID=function(e){var t=e.replace(xe,be);return function(e){var n="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return n&&n.value===t}},C.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&F){var n,r,o,i=t.getElementById(e);if(i){if(n=i.getAttributeNode("id"),n&&n.value===e)return[i];for(o=t.getElementsByName(e),r=0;i=o[r++];)if(n=i.getAttributeNode("id"),n&&n.value===e)return[i]}return[]}}),C.find.TAG=T.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):T.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],o=0,i=t.getElementsByTagName(e);if("*"===e){for(;n=i[o++];)1===n.nodeType&&r.push(n);return r}return i},C.find.CLASS=T.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&F)return t.getElementsByClassName(e)},I=[],R=[],(T.qsa=me.test(L.querySelectorAll))&&(o(function(e){H.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&R.push("[*^$]="+ne+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||R.push("\\["+ne+"*(?:value|"+te+")"),e.querySelectorAll("[id~="+$+"-]").length||R.push("~="),e.querySelectorAll(":checked").length||R.push(":checked"),e.querySelectorAll("a#"+$+"+*").length||R.push(".#.+[+~]")}),o(function(e){e.innerHTML="";var t=L.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&R.push("name"+ne+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&R.push(":enabled",":disabled"),H.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&R.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),R.push(",.*:")})),(T.matchesSelector=me.test(P=H.matches||H.webkitMatchesSelector||H.mozMatchesSelector||H.oMatchesSelector||H.msMatchesSelector))&&o(function(e){T.disconnectedMatch=P.call(e,"*"),P.call(e,"[s!='']:x"),I.push("!=",ie)}),R=R.length&&new RegExp(R.join("|")),I=I.length&&new RegExp(I.join("|")),t=me.test(H.compareDocumentPosition),M=t||me.test(H.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)for(;t=t.parentNode;)if(t===e)return!0;return!1},V=t?function(e,t){if(e===t)return D=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n?n:(n=(e.ownerDocument||e)===(t.ownerDocument||t)?e.compareDocumentPosition(t):1,1&n||!T.sortDetached&&t.compareDocumentPosition(e)===n?e===L||e.ownerDocument===W&&M(W,e)?-1:t===L||t.ownerDocument===W&&M(W,t)?1:q?ee(q,e)-ee(q,t):0:4&n?-1:1)}:function(e,t){if(e===t)return D=!0,0;var n,r=0,o=e.parentNode,i=t.parentNode,a=[e],u=[t];if(!o||!i)return e===L?-1:t===L?1:o?-1:i?1:q?ee(q,e)-ee(q,t):0;if(o===i)return s(e,t);for(n=e;n=n.parentNode;)a.unshift(n);for(n=t;n=n.parentNode;)u.unshift(n);for(;a[r]===u[r];)r++;return r?s(a[r],u[r]):a[r]===W?-1:u[r]===W?1:0},L):L},t.matches=function(e,n){return t(e,null,null,n)},t.matchesSelector=function(e,n){if((e.ownerDocument||e)!==L&&O(e),n=n.replace(le,"='$1']"),T.matchesSelector&&F&&!X[n+" "]&&(!I||!I.test(n))&&(!R||!R.test(n)))try{var r=P.call(e,n);if(r||T.disconnectedMatch||e.document&&11!==e.document.nodeType)return r}catch(e){}return t(n,L,null,[e]).length>0},t.contains=function(e,t){return(e.ownerDocument||e)!==L&&O(e),M(e,t)},t.attr=function(e,t){(e.ownerDocument||e)!==L&&O(e);var n=C.attrHandle[t.toLowerCase()],r=n&&G.call(C.attrHandle,t.toLowerCase())?n(e,t,!F):void 0;return void 0!==r?r:T.attributes||!F?e.getAttribute(t):(r=e.getAttributeNode(t))&&r.specified?r.value:null},t.escape=function(e){return(e+"").replace(we,Te)},t.error=function(e){throw new Error("Syntax error, unrecognized expression: "+e)},t.uniqueSort=function(e){var t,n=[],r=0,o=0;if(D=!T.detectDuplicates,q=!T.sortStable&&e.slice(0),e.sort(V),D){for(;t=e[o++];)t===e[o]&&(r=n.push(o));for(;r--;)e.splice(n[r],1)}return q=null,e},j=t.getText=function(e){var t,n="",r=0,o=e.nodeType;if(o){if(1===o||9===o||11===o){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=j(e)}else if(3===o||4===o)return e.nodeValue}else for(;t=e[r++];)n+=j(t);return n},C=t.selectors={cacheLength:50,createPseudo:r,match:he,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(xe,be),e[3]=(e[3]||e[4]||e[5]||"").replace(xe,be),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||t.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&t.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return he.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&fe.test(n)&&(t=E(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(xe,be).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=U[e+" "];return t||(t=new RegExp("(^|"+ne+")"+e+"("+ne+"|$)"))&&U(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(e,n,r){return function(o){var i=t.attr(o,e);return null==i?"!="===n:!n||(i+="","="===n?i===r:"!="===n?i!==r:"^="===n?r&&0===i.indexOf(r):"*="===n?r&&i.indexOf(r)>-1:"$="===n?r&&i.slice(-r.length)===r:"~="===n?(" "+i.replace(se," ")+" ").indexOf(r)>-1:"|="===n&&(i===r||i.slice(0,r.length+1)===r+"-"))}},CHILD:function(e,t,n,r,o){var i="nth"!==e.slice(0,3),s="last"!==e.slice(-4),a="of-type"===t;return 1===r&&0===o?function(e){return!!e.parentNode}:function(t,n,u){var c,l,f,p,h,d,g=i!==s?"nextSibling":"previousSibling",m=t.parentNode,v=a&&t.nodeName.toLowerCase(),y=!u&&!a,x=!1;if(m){if(i){for(;g;){for(p=t;p=p[g];)if(a?p.nodeName.toLowerCase()===v:1===p.nodeType)return!1;d=g="only"===e&&!d&&"nextSibling"}return!0}if(d=[s?m.firstChild:m.lastChild],s&&y){for(p=m,f=p[$]||(p[$]={}),l=f[p.uniqueID]||(f[p.uniqueID]={}),c=l[e]||[],h=c[0]===B&&c[1],x=h&&c[2],p=h&&m.childNodes[h];p=++h&&p&&p[g]||(x=h=0)||d.pop();)if(1===p.nodeType&&++x&&p===t){l[e]=[B,h,x];break}}else if(y&&(p=t,f=p[$]||(p[$]={}),l=f[p.uniqueID]||(f[p.uniqueID]={}),c=l[e]||[],h=c[0]===B&&c[1],x=h),x===!1)for(;(p=++h&&p&&p[g]||(x=h=0)||d.pop())&&((a?p.nodeName.toLowerCase()!==v:1!==p.nodeType)||!++x||(y&&(f=p[$]||(p[$]={}),l=f[p.uniqueID]||(f[p.uniqueID]={}),l[e]=[B,x]),p!==t)););return x-=o,x===r||x%r===0&&x/r>=0}}},PSEUDO:function(e,n){var o,i=C.pseudos[e]||C.setFilters[e.toLowerCase()]||t.error("unsupported pseudo: "+e);return i[$]?i(n):i.length>1?(o=[e,e,"",n],C.setFilters.hasOwnProperty(e.toLowerCase())?r(function(e,t){for(var r,o=i(e,n),s=o.length;s--;)r=ee(e,o[s]),e[r]=!(t[r]=o[s])}):function(e){return i(e,0,o)}):i}},pseudos:{not:r(function(e){var t=[],n=[],o=S(e.replace(ae,"$1"));return o[$]?r(function(e,t,n,r){for(var i,s=o(e,null,r,[]),a=e.length;a--;)(i=s[a])&&(e[a]=!(t[a]=i))}):function(e,r,i){return t[0]=e,o(t,null,i,n),t[0]=null,!n.pop()}}),has:r(function(e){return function(n){ -return t(e,n).length>0}}),contains:r(function(e){return e=e.replace(xe,be),function(t){return(t.textContent||t.innerText||j(t)).indexOf(e)>-1}}),lang:r(function(e){return pe.test(e||"")||t.error("unsupported lang: "+e),e=e.replace(xe,be).toLowerCase(),function(t){var n;do if(n=F?t.lang:t.getAttribute("xml:lang")||t.getAttribute("lang"))return n=n.toLowerCase(),n===e||0===n.indexOf(e+"-");while((t=t.parentNode)&&1===t.nodeType);return!1}}),target:function(t){var n=e.location&&e.location.hash;return n&&n.slice(1)===t.id},root:function(e){return e===H},focus:function(e){return e===L.activeElement&&(!L.hasFocus||L.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:c(!1),disabled:c(!0),checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,e.selected===!0},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeType<6)return!1;return!0},parent:function(e){return!C.pseudos.empty(e)},header:function(e){return ge.test(e.nodeName)},input:function(e){return de.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||"text"===t.toLowerCase())},first:l(function(){return[0]}),last:l(function(e,t){return[t-1]}),eq:l(function(e,t,n){return[n<0?n+t:n]}),even:l(function(e,t){for(var n=0;n=0;)e.push(r);return e}),gt:l(function(e,t,n){for(var r=n<0?n+t:n;++r2&&"ID"===(s=i[0]).type&&9===t.nodeType&&F&&C.relative[i[1].type]){if(t=(C.find.ID(s.matches[0].replace(xe,be),t)||[])[0],!t)return n;c&&(t=t.parentNode),e=e.slice(i.shift().value.length)}for(o=he.needsContext.test(e)?0:i.length;o--&&(s=i[o],!C.relative[a=s.type]);)if((u=C.find[a])&&(r=u(s.matches[0].replace(xe,be),ye.test(i[0].type)&&f(t.parentNode)||t))){if(i.splice(o,1),e=r.length&&h(i),!e)return K.apply(n,r),n;break}}return(c||S(e,l))(r,t,!F,n,!t||ye.test(e)&&f(t.parentNode)||t),n},T.sortStable=$.split("").sort(V).join("")===$,T.detectDuplicates=!!D,O(),T.sortDetached=o(function(e){return 1&e.compareDocumentPosition(L.createElement("fieldset"))}),o(function(e){return e.innerHTML="","#"===e.firstChild.getAttribute("href")})||i("type|href|height|width",function(e,t,n){if(!n)return e.getAttribute(t,"type"===t.toLowerCase()?1:2)}),T.attributes&&o(function(e){return e.innerHTML="",e.firstChild.setAttribute("value",""),""===e.firstChild.getAttribute("value")})||i("value",function(e,t,n){if(!n&&"input"===e.nodeName.toLowerCase())return e.defaultValue}),o(function(e){return null==e.getAttribute("disabled")})||i(te,function(e,t,n){var r;if(!n)return e[t]===!0?t.toLowerCase():(r=e.getAttributeNode(t))&&r.specified?r.value:null}),t}(e);de.find=xe,de.expr=xe.selectors,de.expr[":"]=de.expr.pseudos,de.uniqueSort=de.unique=xe.uniqueSort,de.text=xe.getText,de.isXMLDoc=xe.isXML,de.contains=xe.contains,de.escapeSelector=xe.escape;var be=function(e,t,n){for(var r=[],o=void 0!==n;(e=e[t])&&9!==e.nodeType;)if(1===e.nodeType){if(o&&de(e).is(n))break;r.push(e)}return r},we=function(e,t){for(var n=[];e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n},Te=de.expr.match.needsContext,Ce=/^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i,je=/^.[^:#\[\.,]*$/;de.filter=function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?de.find.matchesSelector(r,e)?[r]:[]:de.find.matches(e,de.grep(t,function(e){return 1===e.nodeType}))},de.fn.extend({find:function(e){var t,n,r=this.length,o=this;if("string"!=typeof e)return this.pushStack(de(e).filter(function(){for(t=0;t1?de.uniqueSort(n):n},filter:function(e){return this.pushStack(o(this,e||[],!1))},not:function(e){return this.pushStack(o(this,e||[],!0))},is:function(e){return!!o(this,"string"==typeof e&&Te.test(e)?de(e):e||[],!1).length}});var ke,Ee=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,Se=de.fn.init=function(e,t,n){var r,o;if(!e)return this;if(n=n||ke,"string"==typeof e){if(r="<"===e[0]&&">"===e[e.length-1]&&e.length>=3?[null,e,null]:Ee.exec(e),!r||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof de?t[0]:t,de.merge(this,de.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:te,!0)),Ce.test(r[1])&&de.isPlainObject(t))for(r in t)de.isFunction(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return o=te.getElementById(r[2]),o&&(this[0]=o,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):de.isFunction(e)?void 0!==n.ready?n.ready(e):e(de):de.makeArray(e,this)};Se.prototype=de.fn,ke=de(te);var Ne=/^(?:parents|prev(?:Until|All))/,Ae={children:!0,contents:!0,next:!0,prev:!0};de.fn.extend({has:function(e){var t=de(e,this),n=t.length;return this.filter(function(){for(var e=0;e-1:1===n.nodeType&&de.find.matchesSelector(n,e))){i.push(n);break}return this.pushStack(i.length>1?de.uniqueSort(i):i)},index:function(e){return e?"string"==typeof e?se.call(de(e),this[0]):se.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){return this.pushStack(de.uniqueSort(de.merge(this.get(),de(e,t))))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}}),de.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return be(e,"parentNode")},parentsUntil:function(e,t,n){return be(e,"parentNode",n)},next:function(e){return i(e,"nextSibling")},prev:function(e){return i(e,"previousSibling")},nextAll:function(e){return be(e,"nextSibling")},prevAll:function(e){return be(e,"previousSibling")},nextUntil:function(e,t,n){return be(e,"nextSibling",n)},prevUntil:function(e,t,n){return be(e,"previousSibling",n)},siblings:function(e){return we((e.parentNode||{}).firstChild,e)},children:function(e){return we(e.firstChild)},contents:function(e){return e.contentDocument||de.merge([],e.childNodes)}},function(e,t){de.fn[e]=function(n,r){var o=de.map(this,t,n);return"Until"!==e.slice(-5)&&(r=n),r&&"string"==typeof r&&(o=de.filter(r,o)),this.length>1&&(Ae[e]||de.uniqueSort(o),Ne.test(e)&&o.reverse()),this.pushStack(o)}});var qe=/[^\x20\t\r\n\f]+/g;de.Callbacks=function(e){e="string"==typeof e?s(e):de.extend({},e);var t,n,r,o,i=[],a=[],u=-1,c=function(){for(o=e.once,r=t=!0;a.length;u=-1)for(n=a.shift();++u-1;)i.splice(n,1),n<=u&&u--}),this},has:function(e){return e?de.inArray(e,i)>-1:i.length>0},empty:function(){return i&&(i=[]),this},disable:function(){return o=a=[],i=n="",this},disabled:function(){return!i},lock:function(){return o=a=[],n||t||(i=n=""),this},locked:function(){return!!o},fireWith:function(e,n){return o||(n=n||[],n=[e,n.slice?n.slice():n],a.push(n),t||c()),this},fire:function(){return l.fireWith(this,arguments),this},fired:function(){return!!r}};return l},de.extend({Deferred:function(t){var n=[["notify","progress",de.Callbacks("memory"),de.Callbacks("memory"),2],["resolve","done",de.Callbacks("once memory"),de.Callbacks("once memory"),0,"resolved"],["reject","fail",de.Callbacks("once memory"),de.Callbacks("once memory"),1,"rejected"]],r="pending",o={state:function(){return r},always:function(){return i.done(arguments).fail(arguments),this},catch:function(e){return o.then(null,e)},pipe:function(){var e=arguments;return de.Deferred(function(t){de.each(n,function(n,r){var o=de.isFunction(e[r[4]])&&e[r[4]];i[r[1]](function(){var e=o&&o.apply(this,arguments);e&&de.isFunction(e.promise)?e.promise().progress(t.notify).done(t.resolve).fail(t.reject):t[r[0]+"With"](this,o?[e]:arguments)})}),e=null}).promise()},then:function(t,r,o){function i(t,n,r,o){return function(){var c=this,l=arguments,f=function(){var e,f;if(!(t=s&&(r!==u&&(c=void 0,l=[e]),n.rejectWith(c,l))}};t?p():(de.Deferred.getStackHook&&(p.stackTrace=de.Deferred.getStackHook()),e.setTimeout(p))}}var s=0;return de.Deferred(function(e){n[0][3].add(i(0,e,de.isFunction(o)?o:a,e.notifyWith)),n[1][3].add(i(0,e,de.isFunction(t)?t:a)),n[2][3].add(i(0,e,de.isFunction(r)?r:u))}).promise()},promise:function(e){return null!=e?de.extend(e,o):o}},i={};return de.each(n,function(e,t){var s=t[2],a=t[5];o[t[1]]=s.add,a&&s.add(function(){r=a},n[3-e][2].disable,n[0][2].lock),s.add(t[3].fire),i[t[0]]=function(){return i[t[0]+"With"](this===i?void 0:this,arguments),this},i[t[0]+"With"]=s.fireWith}),o.promise(i),t&&t.call(i,i),i},when:function(e){var t=arguments.length,n=t,r=Array(n),o=re.call(arguments),i=de.Deferred(),s=function(e){return function(n){r[e]=this,o[e]=arguments.length>1?re.call(arguments):n,--t||i.resolveWith(r,o)}};if(t<=1&&(c(e,i.done(s(n)).resolve,i.reject),"pending"===i.state()||de.isFunction(o[n]&&o[n].then)))return i.then();for(;n--;)c(o[n],s(n),i.reject);return i.promise()}});var De=/^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;de.Deferred.exceptionHook=function(t,n){e.console&&e.console.warn&&t&&De.test(t.name)&&e.console.warn("jQuery.Deferred exception: "+t.message,t.stack,n)},de.readyException=function(t){e.setTimeout(function(){throw t})};var Oe=de.Deferred();de.fn.ready=function(e){return Oe.then(e).catch(function(e){de.readyException(e)}),this},de.extend({isReady:!1,readyWait:1,holdReady:function(e){e?de.readyWait++:de.ready(!0)},ready:function(e){(e===!0?--de.readyWait:de.isReady)||(de.isReady=!0,e!==!0&&--de.readyWait>0||Oe.resolveWith(te,[de]))}}),de.ready.then=Oe.then,"complete"===te.readyState||"loading"!==te.readyState&&!te.documentElement.doScroll?e.setTimeout(de.ready):(te.addEventListener("DOMContentLoaded",l),e.addEventListener("load",l));var Le=function(e,t,n,r,o,i,s){var a=0,u=e.length,c=null==n;if("object"===de.type(n)){o=!0;for(a in n)Le(e,t,a,n[a],!0,i,s)}else if(void 0!==r&&(o=!0,de.isFunction(r)||(s=!0),c&&(s?(t.call(e,r),t=null):(c=t,t=function(e,t,n){return c.call(de(e),n)})),t))for(;a1,null,!0)},removeData:function(e){return this.each(function(){Re.remove(this,e)})}}),de.extend({queue:function(e,t,n){var r;if(e)return t=(t||"fx")+"queue",r=Fe.get(e,t),n&&(!r||de.isArray(n)?r=Fe.access(e,t,de.makeArray(n)):r.push(n)),r||[]},dequeue:function(e,t){t=t||"fx";var n=de.queue(e,t),r=n.length,o=n.shift(),i=de._queueHooks(e,t),s=function(){de.dequeue(e,t)};"inprogress"===o&&(o=n.shift(),r--),o&&("fx"===t&&n.unshift("inprogress"),delete i.stop,o.call(e,s,i)),!r&&i&&i.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return Fe.get(e,n)||Fe.access(e,n,{empty:de.Callbacks("once memory").add(function(){Fe.remove(e,[t+"queue",n])})})}}),de.fn.extend({queue:function(e,t){var n=2;return"string"!=typeof e&&(t=e,e="fx",n--),arguments.length\x20\t\r\n\f]+)/i,Ve=/^$|\/(?:java|ecma)script/i,Ge={option:[1,""],thead:[1,"","
                              "],col:[2,"","
                              "],tr:[2,"","
                              "],td:[3,"","
                              "],_default:[0,"",""]};Ge.optgroup=Ge.option,Ge.tbody=Ge.tfoot=Ge.colgroup=Ge.caption=Ge.thead,Ge.th=Ge.td;var Ye=/<|&#?\w+;/;!function(){var e=te.createDocumentFragment(),t=e.appendChild(te.createElement("div")),n=te.createElement("input");n.setAttribute("type","radio"),n.setAttribute("checked","checked"),n.setAttribute("name","t"),t.appendChild(n),pe.checkClone=t.cloneNode(!0).cloneNode(!0).lastChild.checked,t.innerHTML="",pe.noCloneChecked=!!t.cloneNode(!0).lastChild.defaultValue}();var Qe=te.documentElement,Je=/^key/,Ke=/^(?:mouse|pointer|contextmenu|drag|drop)|click/,Ze=/^([^.]*)(?:\.(.+)|)/;de.event={global:{},add:function(e,t,n,r,o){var i,s,a,u,c,l,f,p,h,d,g,m=Fe.get(e);if(m)for(n.handler&&(i=n,n=i.handler,o=i.selector),o&&de.find.matchesSelector(Qe,o),n.guid||(n.guid=de.guid++),(u=m.events)||(u=m.events={}),(s=m.handle)||(s=m.handle=function(t){return"undefined"!=typeof de&&de.event.triggered!==t.type?de.event.dispatch.apply(e,arguments):void 0}),t=(t||"").match(qe)||[""],c=t.length;c--;)a=Ze.exec(t[c])||[],h=g=a[1],d=(a[2]||"").split(".").sort(),h&&(f=de.event.special[h]||{},h=(o?f.delegateType:f.bindType)||h,f=de.event.special[h]||{},l=de.extend({type:h,origType:g,data:r,handler:n,guid:n.guid,selector:o,needsContext:o&&de.expr.match.needsContext.test(o),namespace:d.join(".")},i),(p=u[h])||(p=u[h]=[],p.delegateCount=0,f.setup&&f.setup.call(e,r,d,s)!==!1||e.addEventListener&&e.addEventListener(h,s)),f.add&&(f.add.call(e,l),l.handler.guid||(l.handler.guid=n.guid)),o?p.splice(p.delegateCount++,0,l):p.push(l),de.event.global[h]=!0)},remove:function(e,t,n,r,o){var i,s,a,u,c,l,f,p,h,d,g,m=Fe.hasData(e)&&Fe.get(e);if(m&&(u=m.events)){for(t=(t||"").match(qe)||[""],c=t.length;c--;)if(a=Ze.exec(t[c])||[],h=g=a[1],d=(a[2]||"").split(".").sort(),h){for(f=de.event.special[h]||{},h=(r?f.delegateType:f.bindType)||h,p=u[h]||[],a=a[2]&&new RegExp("(^|\\.)"+d.join("\\.(?:.*\\.|)")+"(\\.|$)"),s=i=p.length;i--;)l=p[i],!o&&g!==l.origType||n&&n.guid!==l.guid||a&&!a.test(l.namespace)||r&&r!==l.selector&&("**"!==r||!l.selector)||(p.splice(i,1),l.selector&&p.delegateCount--,f.remove&&f.remove.call(e,l));s&&!p.length&&(f.teardown&&f.teardown.call(e,d,m.handle)!==!1||de.removeEvent(e,h,m.handle),delete u[h])}else for(h in u)de.event.remove(e,h+t[c],n,r,!0);de.isEmptyObject(u)&&Fe.remove(e,"handle events")}},dispatch:function(e){var t,n,r,o,i,s,a=de.event.fix(e),u=new Array(arguments.length),c=(Fe.get(this,"events")||{})[a.type]||[],l=de.event.special[a.type]||{};for(u[0]=a,t=1;t=1))for(;c!==this;c=c.parentNode||this)if(1===c.nodeType&&("click"!==e.type||c.disabled!==!0)){for(i=[],s={},n=0;n-1:de.find(o,this,null,[c]).length),s[o]&&i.push(r);i.length&&a.push({elem:c,handlers:i})}return c=this,u\x20\t\r\n\f]*)[^>]*)\/>/gi,tt=/\s*$/g;de.extend({htmlPrefilter:function(e){return e.replace(et,"<$1>")},clone:function(e,t,n){var r,o,i,s,a=e.cloneNode(!0),u=de.contains(e.ownerDocument,e);if(!(pe.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||de.isXMLDoc(e)))for(s=v(a),i=v(e),r=0,o=i.length;r0&&y(s,!u&&v(e,"script")),a},cleanData:function(e){for(var t,n,r,o=de.event.special,i=0;void 0!==(n=e[i]);i++)if(He(n)){if(t=n[Fe.expando]){if(t.events)for(r in t.events)o[r]?de.event.remove(n,r):de.removeEvent(n,r,t.handle);n[Fe.expando]=void 0}n[Re.expando]&&(n[Re.expando]=void 0)}}}),de.fn.extend({detach:function(e){return q(this,e,!0)},remove:function(e){return q(this,e)},text:function(e){return Le(this,function(e){return void 0===e?de.text(this):this.empty().each(function(){1!==this.nodeType&&11!==this.nodeType&&9!==this.nodeType||(this.textContent=e)})},null,e,arguments.length)},append:function(){return A(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=j(this,e);t.appendChild(e)}})},prepend:function(){return A(this,arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=j(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return A(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return A(this,arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},empty:function(){for(var e,t=0;null!=(e=this[t]);t++)1===e.nodeType&&(de.cleanData(v(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null!=e&&e,t=null==t?e:t,this.map(function(){return de.clone(this,e,t)})},html:function(e){return Le(this,function(e){var t=this[0]||{},n=0,r=this.length;if(void 0===e&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!tt.test(e)&&!Ge[(Xe.exec(e)||["",""])[1].toLowerCase()]){e=de.htmlPrefilter(e);try{for(;n1)}}),de.Tween=I,I.prototype={constructor:I,init:function(e,t,n,r,o,i){this.elem=e,this.prop=n,this.easing=o||de.easing._default,this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=i||(de.cssNumber[n]?"":"px")},cur:function(){var e=I.propHooks[this.prop];return e&&e.get?e.get(this):I.propHooks._default.get(this)},run:function(e){var t,n=I.propHooks[this.prop];return this.options.duration?this.pos=t=de.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):this.pos=t=e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):I.propHooks._default.set(this),this}},I.prototype.init.prototype=I.prototype,I.propHooks={_default:{get:function(e){var t;return 1!==e.elem.nodeType||null!=e.elem[e.prop]&&null==e.elem.style[e.prop]?e.elem[e.prop]:(t=de.css(e.elem,e.prop,""),t&&"auto"!==t?t:0)},set:function(e){de.fx.step[e.prop]?de.fx.step[e.prop](e):1!==e.elem.nodeType||null==e.elem.style[de.cssProps[e.prop]]&&!de.cssHooks[e.prop]?e.elem[e.prop]=e.now:de.style(e.elem,e.prop,e.now+e.unit)}}},I.propHooks.scrollTop=I.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},de.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2},_default:"swing"},de.fx=I.prototype.init,de.fx.step={};var ht,dt,gt=/^(?:toggle|show|hide)$/,mt=/queueHooks$/;de.Animation=de.extend(U,{tweeners:{"*":[function(e,t){var n=this.createTween(e,t);return d(n.elem,e,$e.exec(t),n),n}]},tweener:function(e,t){de.isFunction(e)?(t=e,e=["*"]):e=e.match(qe);for(var n,r=0,o=e.length;r1)},removeAttr:function(e){return this.each(function(){de.removeAttr(this,e)})}}),de.extend({attr:function(e,t,n){var r,o,i=e.nodeType;if(3!==i&&8!==i&&2!==i)return"undefined"==typeof e.getAttribute?de.prop(e,t,n):(1===i&&de.isXMLDoc(e)||(o=de.attrHooks[t.toLowerCase()]||(de.expr.match.bool.test(t)?vt:void 0)),void 0!==n?null===n?void de.removeAttr(e,t):o&&"set"in o&&void 0!==(r=o.set(e,n,t))?r:(e.setAttribute(t,n+""),n):o&&"get"in o&&null!==(r=o.get(e,t))?r:(r=de.find.attr(e,t),null==r?void 0:r))},attrHooks:{type:{set:function(e,t){if(!pe.radioValue&&"radio"===t&&de.nodeName(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},removeAttr:function(e,t){var n,r=0,o=t&&t.match(qe);if(o&&1===e.nodeType)for(;n=o[r++];)e.removeAttribute(n)}}),vt={set:function(e,t,n){return t===!1?de.removeAttr(e,n):e.setAttribute(n,n),n}},de.each(de.expr.match.bool.source.match(/\w+/g),function(e,t){var n=yt[t]||de.find.attr;yt[t]=function(e,t,r){var o,i,s=t.toLowerCase();return r||(i=yt[s],yt[s]=o,o=null!=n(e,t,r)?s:null,yt[s]=i),o}});var xt=/^(?:input|select|textarea|button)$/i,bt=/^(?:a|area)$/i;de.fn.extend({prop:function(e,t){return Le(this,de.prop,e,t,arguments.length>1)},removeProp:function(e){return this.each(function(){delete this[de.propFix[e]||e]})}}),de.extend({prop:function(e,t,n){var r,o,i=e.nodeType;if(3!==i&&8!==i&&2!==i)return 1===i&&de.isXMLDoc(e)||(t=de.propFix[t]||t,o=de.propHooks[t]),void 0!==n?o&&"set"in o&&void 0!==(r=o.set(e,n,t))?r:e[t]=n:o&&"get"in o&&null!==(r=o.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){var t=de.find.attr(e,"tabindex");return t?parseInt(t,10):xt.test(e.nodeName)||bt.test(e.nodeName)&&e.href?0:-1}}},propFix:{for:"htmlFor",class:"className"}}),pe.optSelected||(de.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null},set:function(e){var t=e.parentNode;t&&(t.selectedIndex,t.parentNode&&t.parentNode.selectedIndex)}}),de.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){de.propFix[this.toLowerCase()]=this}),de.fn.extend({addClass:function(e){var t,n,r,o,i,s,a,u=0;if(de.isFunction(e))return this.each(function(t){de(this).addClass(e.call(this,t,X(this)))});if("string"==typeof e&&e)for(t=e.match(qe)||[];n=this[u++];)if(o=X(n),r=1===n.nodeType&&" "+z(o)+" "){for(s=0;i=t[s++];)r.indexOf(" "+i+" ")<0&&(r+=i+" ");a=z(r),o!==a&&n.setAttribute("class",a)}return this},removeClass:function(e){var t,n,r,o,i,s,a,u=0;if(de.isFunction(e))return this.each(function(t){de(this).removeClass(e.call(this,t,X(this)))});if(!arguments.length)return this.attr("class","");if("string"==typeof e&&e)for(t=e.match(qe)||[];n=this[u++];)if(o=X(n),r=1===n.nodeType&&" "+z(o)+" "){for(s=0;i=t[s++];)for(;r.indexOf(" "+i+" ")>-1;)r=r.replace(" "+i+" "," ");a=z(r),o!==a&&n.setAttribute("class",a)}return this},toggleClass:function(e,t){var n=typeof e;return"boolean"==typeof t&&"string"===n?t?this.addClass(e):this.removeClass(e):de.isFunction(e)?this.each(function(n){de(this).toggleClass(e.call(this,n,X(this),t),t)}):this.each(function(){var t,r,o,i;if("string"===n)for(r=0,o=de(this),i=e.match(qe)||[];t=i[r++];)o.hasClass(t)?o.removeClass(t):o.addClass(t);else void 0!==e&&"boolean"!==n||(t=X(this),t&&Fe.set(this,"__className__",t),this.setAttribute&&this.setAttribute("class",t||e===!1?"":Fe.get(this,"__className__")||""))})},hasClass:function(e){var t,n,r=0;for(t=" "+e+" ";n=this[r++];)if(1===n.nodeType&&(" "+z(X(n))+" ").indexOf(t)>-1)return!0;return!1}});var wt=/\r/g;de.fn.extend({val:function(e){var t,n,r,o=this[0];{if(arguments.length)return r=de.isFunction(e),this.each(function(n){var o;1===this.nodeType&&(o=r?e.call(this,n,de(this).val()):e,null==o?o="":"number"==typeof o?o+="":de.isArray(o)&&(o=de.map(o,function(e){return null==e?"":e+""})),t=de.valHooks[this.type]||de.valHooks[this.nodeName.toLowerCase()],t&&"set"in t&&void 0!==t.set(this,o,"value")||(this.value=o))});if(o)return t=de.valHooks[o.type]||de.valHooks[o.nodeName.toLowerCase()],t&&"get"in t&&void 0!==(n=t.get(o,"value"))?n:(n=o.value,"string"==typeof n?n.replace(wt,""):null==n?"":n)}}}),de.extend({valHooks:{option:{get:function(e){var t=de.find.attr(e,"value");return null!=t?t:z(de.text(e))}},select:{get:function(e){var t,n,r,o=e.options,i=e.selectedIndex,s="select-one"===e.type,a=s?null:[],u=s?i+1:o.length;for(r=i<0?u:s?i:0;r-1)&&(n=!0);return n||(e.selectedIndex=-1),i}}}}),de.each(["radio","checkbox"],function(){de.valHooks[this]={set:function(e,t){if(de.isArray(t))return e.checked=de.inArray(de(e).val(),t)>-1}},pe.checkOn||(de.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})});var Tt=/^(?:focusinfocus|focusoutblur)$/;de.extend(de.event,{trigger:function(t,n,r,o){var i,s,a,u,c,l,f,p=[r||te],h=ce.call(t,"type")?t.type:t,d=ce.call(t,"namespace")?t.namespace.split("."):[];if(s=a=r=r||te,3!==r.nodeType&&8!==r.nodeType&&!Tt.test(h+de.event.triggered)&&(h.indexOf(".")>-1&&(d=h.split("."),h=d.shift(),d.sort()),c=h.indexOf(":")<0&&"on"+h,t=t[de.expando]?t:new de.Event(h,"object"==typeof t&&t),t.isTrigger=o?2:3,t.namespace=d.join("."),t.rnamespace=t.namespace?new RegExp("(^|\\.)"+d.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,t.result=void 0,t.target||(t.target=r),n=null==n?[t]:de.makeArray(n,[t]),f=de.event.special[h]||{},o||!f.trigger||f.trigger.apply(r,n)!==!1)){if(!o&&!f.noBubble&&!de.isWindow(r)){for(u=f.delegateType||h,Tt.test(u+h)||(s=s.parentNode);s;s=s.parentNode)p.push(s),a=s;a===(r.ownerDocument||te)&&p.push(a.defaultView||a.parentWindow||e)}for(i=0;(s=p[i++])&&!t.isPropagationStopped();)t.type=i>1?u:f.bindType||h,l=(Fe.get(s,"events")||{})[t.type]&&Fe.get(s,"handle"),l&&l.apply(s,n),l=c&&s[c],l&&l.apply&&He(s)&&(t.result=l.apply(s,n),t.result===!1&&t.preventDefault());return t.type=h,o||t.isDefaultPrevented()||f._default&&f._default.apply(p.pop(),n)!==!1||!He(r)||c&&de.isFunction(r[h])&&!de.isWindow(r)&&(a=r[c],a&&(r[c]=null),de.event.triggered=h,r[h](),de.event.triggered=void 0,a&&(r[c]=a)),t.result}},simulate:function(e,t,n){var r=de.extend(new de.Event,n,{type:e,isSimulated:!0});de.event.trigger(r,null,t)}}),de.fn.extend({trigger:function(e,t){return this.each(function(){de.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];if(n)return de.event.trigger(e,t,n,!0)}}),de.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,t){de.fn[t]=function(e,n){return arguments.length>0?this.on(t,null,e,n):this.trigger(t)}}),de.fn.extend({hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),pe.focusin="onfocusin"in e,pe.focusin||de.each({focus:"focusin",blur:"focusout"},function(e,t){var n=function(e){de.event.simulate(t,e.target,de.event.fix(e))};de.event.special[t]={setup:function(){var r=this.ownerDocument||this,o=Fe.access(r,t);o||r.addEventListener(e,n,!0),Fe.access(r,t,(o||0)+1)},teardown:function(){var r=this.ownerDocument||this,o=Fe.access(r,t)-1;o?Fe.access(r,t,o):(r.removeEventListener(e,n,!0),Fe.remove(r,t))}}});var Ct=e.location,jt=de.now(),kt=/\?/;de.parseXML=function(t){var n;if(!t||"string"!=typeof t)return null;try{n=(new e.DOMParser).parseFromString(t,"text/xml")}catch(e){n=void 0}return n&&!n.getElementsByTagName("parsererror").length||de.error("Invalid XML: "+t),n};var Et=/\[\]$/,St=/\r?\n/g,Nt=/^(?:submit|button|image|reset|file)$/i,At=/^(?:input|select|textarea|keygen)/i;de.param=function(e,t){var n,r=[],o=function(e,t){var n=de.isFunction(t)?t():t;r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(null==n?"":n)};if(de.isArray(e)||e.jquery&&!de.isPlainObject(e))de.each(e,function(){o(this.name,this.value)});else for(n in e)V(n,e[n],t,o);return r.join("&")},de.fn.extend({serialize:function(){return de.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=de.prop(this,"elements");return e?de.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!de(this).is(":disabled")&&At.test(this.nodeName)&&!Nt.test(e)&&(this.checked||!ze.test(e))}).map(function(e,t){var n=de(this).val();return null==n?null:de.isArray(n)?de.map(n,function(e){return{name:t.name,value:e.replace(St,"\r\n")}}):{name:t.name,value:n.replace(St,"\r\n")}}).get()}});var qt=/%20/g,Dt=/#.*$/,Ot=/([?&])_=[^&]*/,Lt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Ht=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Ft=/^(?:GET|HEAD)$/,Rt=/^\/\//,It={},Pt={},Mt="*/".concat("*"),$t=te.createElement("a");$t.href=Ct.href,de.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Ct.href,type:"GET",isLocal:Ht.test(Ct.protocol),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Mt,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/\bxml\b/,html:/\bhtml/,json:/\bjson\b/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":JSON.parse,"text xml":de.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?Q(Q(e,de.ajaxSettings),t):Q(de.ajaxSettings,e)},ajaxPrefilter:G(It),ajaxTransport:G(Pt),ajax:function(t,n){function r(t,n,r,a){var c,p,h,b,w,T=n;l||(l=!0,u&&e.clearTimeout(u),o=void 0,s=a||"",C.readyState=t>0?4:0,c=t>=200&&t<300||304===t,r&&(b=J(d,C,r)),b=K(d,b,C,c),c?(d.ifModified&&(w=C.getResponseHeader("Last-Modified"),w&&(de.lastModified[i]=w),w=C.getResponseHeader("etag"),w&&(de.etag[i]=w)),204===t||"HEAD"===d.type?T="nocontent":304===t?T="notmodified":(T=b.state,p=b.data,h=b.error,c=!h)):(h=T,!t&&T||(T="error",t<0&&(t=0))),C.status=t,C.statusText=(n||T)+"",c?v.resolveWith(g,[p,T,C]):v.rejectWith(g,[C,T,h]),C.statusCode(x),x=void 0,f&&m.trigger(c?"ajaxSuccess":"ajaxError",[C,d,c?p:h]),y.fireWith(g,[C,T]),f&&(m.trigger("ajaxComplete",[C,d]),--de.active||de.event.trigger("ajaxStop")))}"object"==typeof t&&(n=t,t=void 0),n=n||{};var o,i,s,a,u,c,l,f,p,h,d=de.ajaxSetup({},n),g=d.context||d,m=d.context&&(g.nodeType||g.jquery)?de(g):de.event,v=de.Deferred(),y=de.Callbacks("once memory"),x=d.statusCode||{},b={},w={},T="canceled",C={readyState:0,getResponseHeader:function(e){var t;if(l){if(!a)for(a={};t=Lt.exec(s);)a[t[1].toLowerCase()]=t[2];t=a[e.toLowerCase()]}return null==t?null:t},getAllResponseHeaders:function(){return l?s:null},setRequestHeader:function(e,t){return null==l&&(e=w[e.toLowerCase()]=w[e.toLowerCase()]||e,b[e]=t),this},overrideMimeType:function(e){return null==l&&(d.mimeType=e),this},statusCode:function(e){var t;if(e)if(l)C.always(e[C.status]);else for(t in e)x[t]=[x[t],e[t]];return this},abort:function(e){var t=e||T;return o&&o.abort(t),r(0,t),this}};if(v.promise(C),d.url=((t||d.url||Ct.href)+"").replace(Rt,Ct.protocol+"//"),d.type=n.method||n.type||d.method||d.type,d.dataTypes=(d.dataType||"*").toLowerCase().match(qe)||[""],null==d.crossDomain){c=te.createElement("a");try{c.href=d.url,c.href=c.href,d.crossDomain=$t.protocol+"//"+$t.host!=c.protocol+"//"+c.host}catch(e){d.crossDomain=!0}}if(d.data&&d.processData&&"string"!=typeof d.data&&(d.data=de.param(d.data,d.traditional)),Y(It,d,n,C),l)return C;f=de.event&&d.global,f&&0===de.active++&&de.event.trigger("ajaxStart"),d.type=d.type.toUpperCase(),d.hasContent=!Ft.test(d.type),i=d.url.replace(Dt,""),d.hasContent?d.data&&d.processData&&0===(d.contentType||"").indexOf("application/x-www-form-urlencoded")&&(d.data=d.data.replace(qt,"+")):(h=d.url.slice(i.length),d.data&&(i+=(kt.test(i)?"&":"?")+d.data,delete d.data),d.cache===!1&&(i=i.replace(Ot,"$1"),h=(kt.test(i)?"&":"?")+"_="+jt++ +h),d.url=i+h),d.ifModified&&(de.lastModified[i]&&C.setRequestHeader("If-Modified-Since",de.lastModified[i]),de.etag[i]&&C.setRequestHeader("If-None-Match",de.etag[i])),(d.data&&d.hasContent&&d.contentType!==!1||n.contentType)&&C.setRequestHeader("Content-Type",d.contentType),C.setRequestHeader("Accept",d.dataTypes[0]&&d.accepts[d.dataTypes[0]]?d.accepts[d.dataTypes[0]]+("*"!==d.dataTypes[0]?", "+Mt+"; q=0.01":""):d.accepts["*"]);for(p in d.headers)C.setRequestHeader(p,d.headers[p]);if(d.beforeSend&&(d.beforeSend.call(g,C,d)===!1||l))return C.abort();if(T="abort",y.add(d.complete),C.done(d.success),C.fail(d.error),o=Y(Pt,d,n,C)){if(C.readyState=1,f&&m.trigger("ajaxSend",[C,d]),l)return C;d.async&&d.timeout>0&&(u=e.setTimeout(function(){C.abort("timeout")},d.timeout));try{l=!1,o.send(b,r)}catch(e){if(l)throw e;r(-1,e)}}else r(-1,"No Transport");return C},getJSON:function(e,t,n){return de.get(e,t,n,"json")},getScript:function(e,t){return de.get(e,void 0,t,"script")}}),de.each(["get","post"],function(e,t){de[t]=function(e,n,r,o){return de.isFunction(n)&&(o=o||r,r=n,n=void 0),de.ajax(de.extend({url:e,type:t,dataType:o,data:n,success:r},de.isPlainObject(e)&&e))}}),de._evalUrl=function(e){return de.ajax({url:e,type:"GET",dataType:"script",cache:!0,async:!1,global:!1,throws:!0})},de.fn.extend({wrapAll:function(e){var t;return this[0]&&(de.isFunction(e)&&(e=e.call(this[0])),t=de(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){for(var e=this;e.firstElementChild;)e=e.firstElementChild;return e}).append(this)),this},wrapInner:function(e){return de.isFunction(e)?this.each(function(t){de(this).wrapInner(e.call(this,t))}):this.each(function(){var t=de(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)})},wrap:function(e){var t=de.isFunction(e);return this.each(function(n){de(this).wrapAll(t?e.call(this,n):e)})},unwrap:function(e){return this.parent(e).not("body").each(function(){de(this).replaceWith(this.childNodes)}),this}}),de.expr.pseudos.hidden=function(e){return!de.expr.pseudos.visible(e)},de.expr.pseudos.visible=function(e){return!!(e.offsetWidth||e.offsetHeight||e.getClientRects().length)},de.ajaxSettings.xhr=function(){try{return new e.XMLHttpRequest}catch(e){}};var Wt={0:200,1223:204},Bt=de.ajaxSettings.xhr();pe.cors=!!Bt&&"withCredentials"in Bt,pe.ajax=Bt=!!Bt,de.ajaxTransport(function(t){var n,r;if(pe.cors||Bt&&!t.crossDomain)return{send:function(o,i){var s,a=t.xhr();if(a.open(t.type,t.url,t.async,t.username,t.password),t.xhrFields)for(s in t.xhrFields)a[s]=t.xhrFields[s];t.mimeType&&a.overrideMimeType&&a.overrideMimeType(t.mimeType),t.crossDomain||o["X-Requested-With"]||(o["X-Requested-With"]="XMLHttpRequest");for(s in o)a.setRequestHeader(s,o[s]);n=function(e){return function(){n&&(n=r=a.onload=a.onerror=a.onabort=a.onreadystatechange=null,"abort"===e?a.abort():"error"===e?"number"!=typeof a.status?i(0,"error"):i(a.status,a.statusText):i(Wt[a.status]||a.status,a.statusText,"text"!==(a.responseType||"text")||"string"!=typeof a.responseText?{binary:a.response}:{text:a.responseText},a.getAllResponseHeaders()))}},a.onload=n(),r=a.onerror=n("error"),void 0!==a.onabort?a.onabort=r:a.onreadystatechange=function(){4===a.readyState&&e.setTimeout(function(){n&&r()})},n=n("abort");try{a.send(t.hasContent&&t.data||null)}catch(e){if(n)throw e}},abort:function(){n&&n()}}}),de.ajaxPrefilter(function(e){e.crossDomain&&(e.contents.script=!1)}),de.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/\b(?:java|ecma)script\b/},converters:{"text script":function(e){return de.globalEval(e),e}}}),de.ajaxPrefilter("script",function(e){void 0===e.cache&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),de.ajaxTransport("script",function(e){if(e.crossDomain){var t,n;return{send:function(r,o){t=de(" - + + - - - - -

                            • - - - - - Introduction - - - - - -
                              • - -
                            • - - - - - TypedDataset: Feature Overview - - - - - -
                              • - -
                            • - - - - - Comparing TypedDatasets with Spark's Datasets - - - + - -
                              • - -
                            • - - - - - Typed Encoders in Frameless - - - - - -
                              • - -
                            • - - - - - Injection: Creating Custom Encoders - - - - - -
                              • - -
                            • - - - - - Job[A] - - - +
                              - -
                              • - -
                            • - - - - - Using Cats with RDDs - - - - - -
                              • - -
                            • - - - - - Using Spark ML with TypedDataset - - - - - -
                              • - -
                            • - - - - - Proof of Concept: TypedDataFrame - - - - - -
                              • - - - - -
                            • - -
                            • - - Published with GitBook +
                              + + -
                              • - - - - - - - -
                              +
                              + + + + + + + + + + + + + +
                              + +
                              - - - - - - - - + - +

                              + + +
                              + +

                              Frameless

                              +

                              Workflow Badge + Codecov Badge + Discord Badge + Maven Badge + Snapshots Badge

                              +

                              Frameless is a Scala library for working with Spark using more expressive types. + It consists of the following modules:

                              +
                                +
                              • frameless-dataset for a more strongly typed Dataset/DataFrame API
                                • +
                              • frameless-ml for a more strongly typed Spark ML API based on frameless-dataset
                                • +
                              • frameless-cats for using Spark's RDD API with cats
                                • +
                              +

                              Note that while Frameless is still getting off the ground, it is very possible that breaking changes will be + made for at least the next few versions.

                              +

                              The Frameless project and contributors support the + Typelevel Code of Conduct and want all its + associated channels (e.g. GitHub, Discord) to be a safe and friendly environment for contributing and learning.

                              - +

                              Versions and dependencies

                              +

                              The compatible versions of Spark and + cats are as follows:

                              + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                              FramelessSparkCatsCats-EffectScala
                              0.4.02.2.01.0.0-IF0.42.11
                              0.4.12.2.01.x0.82.11
                              0.5.22.2.11.x0.82.11
                              0.6.12.3.01.x0.82.11
                              0.7.02.3.11.x1.x2.11
                              0.8.02.4.01.x1.x2.11 / 2.12
                              0.9.03.0.01.x1.x2.12
                              0.10.13.1.02.x2.x2.12
                              0.11.0*3.2.0 / 3.1.2 / 3.0.12.x2.x2.12 / 2.13
                              0.11.13.2.0 / 3.1.2 / 3.0.12.x2.x2.12 / 2.13
                              +

                              * 0.11.0 has broken Spark 3.1.2 and 3.0.1 artifacts published.

                              +

                              Starting 0.11 we introduced Spark cross published artifacts: + * By default, frameless artifacts depend on the most recent Spark version + * Suffix -spark{major}{minor} is added to artifacts that are released for the previous Spark version(s)

                              +

                              Artifact names examples:

                              +
                                +
                              • frameless-dataset (the latest Spark dependency)
                                • +
                              • frameless-dataset-spark31 (Spark 3.1.x dependency)
                                • +
                              • frameless-dataset-spark30 (Spark 3.0.x dependency)
                                • +
                              +

                              Versions 0.5.x and 0.6.x have identical features. The first is compatible with Spark 2.2.1 and the second with 2.3.0.

                              +

                              The only dependency of the frameless-dataset module is on shapeless 2.3.2. + Therefore, depending on frameless-dataset, has a minimal overhead on your Spark's application jar. + Only the frameless-cats module depends on cats and cats-effect, so if you prefer to work just with Datasets and not with RDDs, + you may choose not to depend on frameless-cats.

                              +

                              Frameless intentionally does not have a compile dependency on Spark. + This essentially allows you to use any version of Frameless with any version of Spark. + The aforementioned table simply provides the versions of Spark we officially compile + and test Frameless with, but other versions may probably work as well.

                              - +

                              Breaking changes in 0.9

                              +
                                +
                              • Spark 3 introduces a new ExpressionEncoder approach, the schema for single value DataFrame's is now "value" not "_1".
                                • +
                              - +

                              Why?

                              +

                              Frameless introduces a new Spark API, called TypedDataset. + The benefits of using TypedDataset compared to the standard Spark Dataset API are as follows:

                              +
                                +
                              • Typesafe columns referencing (e.g., no more runtime errors when accessing non-existing columns)
                                • +
                              • Customizable, typesafe encoders (e.g., if a type does not have an encoder, it should not compile)
                                • +
                              • Enhanced type signature for built-in functions (e.g., if you apply an arithmetic operation on a non-numeric column, you + get a compilation error)
                                • +
                              • Typesafe casting and projections
                                • +
                              +

                              Click here for a + detailed comparison of TypedDataset with Spark's Dataset API.

                              - +

                              Documentation

                              + - +

                              Quick Start

                              +

                              Since the 0.9.x release, Frameless is compiled only against Scala 2.12.x.

                              +

                              To use Frameless in your project add the following in your build.sbt file as needed:

                              + 
                              val framelessVersion = "0.9.0" // for Spark 3.0.0
+
+libraryDependencies ++= List(
+  "org.typelevel" %% "frameless-dataset" % framelessVersion,
+  "org.typelevel" %% "frameless-ml"      % framelessVersion,
+  "org.typelevel" %% "frameless-cats"    % framelessVersion  
+)
                              +

                              An easy way to bootstrap a Frameless sbt project:

                              +
                                +
                              • if you have Giter8 installed then simply:
                                • +
                              + 
                              g8 imarios/frameless.g8
                              +
                                +
                              • with sbt >= 0.13.13:
                                • +
                              + 
                              sbt new imarios/frameless.g8
                              +

                              Typing sbt console inside your project will bring up a shell with Frameless + and all its dependencies loaded (including Spark).

                              - +

                              Need help?

                              +

                              Feel free to messages us on our discord + channel for any issues/questions.

                              - +

                              Development

                              +

                              We require at least one sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers + (people who can merge pull requests) are:

                              + - +

                              Testing

                              +

                              Frameless contains several property tests. To avoid OutOfMemoryErrors, we + tune the default generator sizes. The following environment variables may + be set to adjust the size of generated collections in the TypedDataSet suite:

                              + + + + + + + + + + + + + + + + + +
                              PropertyDefault
                              FRAMELESSGENMIN_SIZE0
                              FRAMELESSGENSIZE_RANGE20
                              - - - - - +

                              License

                              +

                              Code is provided under the Apache 2.0 license available at http://opensource.org/licenses/Apache-2.0, + as well as in the LICENSE file. This is the same license used as Spark.

                              - - +
                              + + + + \ No newline at end of file diff --git a/iris.data b/iris.data new file mode 100644 index 000000000..5c4316cd6 --- /dev/null +++ b/iris.data @@ -0,0 +1,151 @@ +5.1,3.5,1.4,0.2,Iris-setosa +4.9,3.0,1.4,0.2,Iris-setosa +4.7,3.2,1.3,0.2,Iris-setosa +4.6,3.1,1.5,0.2,Iris-setosa +5.0,3.6,1.4,0.2,Iris-setosa +5.4,3.9,1.7,0.4,Iris-setosa +4.6,3.4,1.4,0.3,Iris-setosa +5.0,3.4,1.5,0.2,Iris-setosa +4.4,2.9,1.4,0.2,Iris-setosa +4.9,3.1,1.5,0.1,Iris-setosa +5.4,3.7,1.5,0.2,Iris-setosa +4.8,3.4,1.6,0.2,Iris-setosa +4.8,3.0,1.4,0.1,Iris-setosa +4.3,3.0,1.1,0.1,Iris-setosa +5.8,4.0,1.2,0.2,Iris-setosa +5.7,4.4,1.5,0.4,Iris-setosa +5.4,3.9,1.3,0.4,Iris-setosa +5.1,3.5,1.4,0.3,Iris-setosa +5.7,3.8,1.7,0.3,Iris-setosa +5.1,3.8,1.5,0.3,Iris-setosa +5.4,3.4,1.7,0.2,Iris-setosa +5.1,3.7,1.5,0.4,Iris-setosa +4.6,3.6,1.0,0.2,Iris-setosa +5.1,3.3,1.7,0.5,Iris-setosa +4.8,3.4,1.9,0.2,Iris-setosa +5.0,3.0,1.6,0.2,Iris-setosa +5.0,3.4,1.6,0.4,Iris-setosa +5.2,3.5,1.5,0.2,Iris-setosa +5.2,3.4,1.4,0.2,Iris-setosa +4.7,3.2,1.6,0.2,Iris-setosa +4.8,3.1,1.6,0.2,Iris-setosa +5.4,3.4,1.5,0.4,Iris-setosa +5.2,4.1,1.5,0.1,Iris-setosa +5.5,4.2,1.4,0.2,Iris-setosa +4.9,3.1,1.5,0.1,Iris-setosa +5.0,3.2,1.2,0.2,Iris-setosa +5.5,3.5,1.3,0.2,Iris-setosa +4.9,3.1,1.5,0.1,Iris-setosa +4.4,3.0,1.3,0.2,Iris-setosa +5.1,3.4,1.5,0.2,Iris-setosa +5.0,3.5,1.3,0.3,Iris-setosa +4.5,2.3,1.3,0.3,Iris-setosa +4.4,3.2,1.3,0.2,Iris-setosa +5.0,3.5,1.6,0.6,Iris-setosa +5.1,3.8,1.9,0.4,Iris-setosa +4.8,3.0,1.4,0.3,Iris-setosa +5.1,3.8,1.6,0.2,Iris-setosa +4.6,3.2,1.4,0.2,Iris-setosa +5.3,3.7,1.5,0.2,Iris-setosa +5.0,3.3,1.4,0.2,Iris-setosa +7.0,3.2,4.7,1.4,Iris-versicolor +6.4,3.2,4.5,1.5,Iris-versicolor +6.9,3.1,4.9,1.5,Iris-versicolor +5.5,2.3,4.0,1.3,Iris-versicolor +6.5,2.8,4.6,1.5,Iris-versicolor +5.7,2.8,4.5,1.3,Iris-versicolor +6.3,3.3,4.7,1.6,Iris-versicolor +4.9,2.4,3.3,1.0,Iris-versicolor +6.6,2.9,4.6,1.3,Iris-versicolor +5.2,2.7,3.9,1.4,Iris-versicolor +5.0,2.0,3.5,1.0,Iris-versicolor +5.9,3.0,4.2,1.5,Iris-versicolor +6.0,2.2,4.0,1.0,Iris-versicolor +6.1,2.9,4.7,1.4,Iris-versicolor +5.6,2.9,3.6,1.3,Iris-versicolor +6.7,3.1,4.4,1.4,Iris-versicolor +5.6,3.0,4.5,1.5,Iris-versicolor +5.8,2.7,4.1,1.0,Iris-versicolor +6.2,2.2,4.5,1.5,Iris-versicolor +5.6,2.5,3.9,1.1,Iris-versicolor +5.9,3.2,4.8,1.8,Iris-versicolor +6.1,2.8,4.0,1.3,Iris-versicolor +6.3,2.5,4.9,1.5,Iris-versicolor +6.1,2.8,4.7,1.2,Iris-versicolor +6.4,2.9,4.3,1.3,Iris-versicolor +6.6,3.0,4.4,1.4,Iris-versicolor +6.8,2.8,4.8,1.4,Iris-versicolor +6.7,3.0,5.0,1.7,Iris-versicolor +6.0,2.9,4.5,1.5,Iris-versicolor +5.7,2.6,3.5,1.0,Iris-versicolor +5.5,2.4,3.8,1.1,Iris-versicolor +5.5,2.4,3.7,1.0,Iris-versicolor +5.8,2.7,3.9,1.2,Iris-versicolor +6.0,2.7,5.1,1.6,Iris-versicolor +5.4,3.0,4.5,1.5,Iris-versicolor +6.0,3.4,4.5,1.6,Iris-versicolor +6.7,3.1,4.7,1.5,Iris-versicolor +6.3,2.3,4.4,1.3,Iris-versicolor +5.6,3.0,4.1,1.3,Iris-versicolor +5.5,2.5,4.0,1.3,Iris-versicolor +5.5,2.6,4.4,1.2,Iris-versicolor +6.1,3.0,4.6,1.4,Iris-versicolor +5.8,2.6,4.0,1.2,Iris-versicolor +5.0,2.3,3.3,1.0,Iris-versicolor +5.6,2.7,4.2,1.3,Iris-versicolor +5.7,3.0,4.2,1.2,Iris-versicolor +5.7,2.9,4.2,1.3,Iris-versicolor +6.2,2.9,4.3,1.3,Iris-versicolor +5.1,2.5,3.0,1.1,Iris-versicolor +5.7,2.8,4.1,1.3,Iris-versicolor +6.3,3.3,6.0,2.5,Iris-virginica +5.8,2.7,5.1,1.9,Iris-virginica +7.1,3.0,5.9,2.1,Iris-virginica +6.3,2.9,5.6,1.8,Iris-virginica +6.5,3.0,5.8,2.2,Iris-virginica +7.6,3.0,6.6,2.1,Iris-virginica +4.9,2.5,4.5,1.7,Iris-virginica +7.3,2.9,6.3,1.8,Iris-virginica +6.7,2.5,5.8,1.8,Iris-virginica +7.2,3.6,6.1,2.5,Iris-virginica +6.5,3.2,5.1,2.0,Iris-virginica +6.4,2.7,5.3,1.9,Iris-virginica +6.8,3.0,5.5,2.1,Iris-virginica +5.7,2.5,5.0,2.0,Iris-virginica +5.8,2.8,5.1,2.4,Iris-virginica +6.4,3.2,5.3,2.3,Iris-virginica +6.5,3.0,5.5,1.8,Iris-virginica +7.7,3.8,6.7,2.2,Iris-virginica +7.7,2.6,6.9,2.3,Iris-virginica +6.0,2.2,5.0,1.5,Iris-virginica +6.9,3.2,5.7,2.3,Iris-virginica +5.6,2.8,4.9,2.0,Iris-virginica +7.7,2.8,6.7,2.0,Iris-virginica +6.3,2.7,4.9,1.8,Iris-virginica +6.7,3.3,5.7,2.1,Iris-virginica +7.2,3.2,6.0,1.8,Iris-virginica +6.2,2.8,4.8,1.8,Iris-virginica +6.1,3.0,4.9,1.8,Iris-virginica +6.4,2.8,5.6,2.1,Iris-virginica +7.2,3.0,5.8,1.6,Iris-virginica +7.4,2.8,6.1,1.9,Iris-virginica +7.9,3.8,6.4,2.0,Iris-virginica +6.4,2.8,5.6,2.2,Iris-virginica +6.3,2.8,5.1,1.5,Iris-virginica +6.1,2.6,5.6,1.4,Iris-virginica +7.7,3.0,6.1,2.3,Iris-virginica +6.3,3.4,5.6,2.4,Iris-virginica +6.4,3.1,5.5,1.8,Iris-virginica +6.0,3.0,4.8,1.8,Iris-virginica +6.9,3.1,5.4,2.1,Iris-virginica +6.7,3.1,5.6,2.4,Iris-virginica +6.9,3.1,5.1,2.3,Iris-virginica +5.8,2.7,5.1,1.9,Iris-virginica +6.8,3.2,5.9,2.3,Iris-virginica +6.7,3.3,5.7,2.5,Iris-virginica +6.7,3.0,5.2,2.3,Iris-virginica +6.3,2.5,5.0,1.9,Iris-virginica +6.5,3.0,5.2,2.0,Iris-virginica +6.2,3.4,5.4,2.3,Iris-virginica +5.9,3.0,5.1,1.8,Iris-virginica + diff --git a/iris.parquet b/iris.parquet new file mode 100644 index 0000000000000000000000000000000000000000..83e0b2e7614665c5a51492f415f2058332cef683 GIT binary patch literal 2597 zcmbtWe@qis9DjG*l~=ffYvIZjE1n%f$x72&K_Hl3nG#TR2#bo!r1Y-PS)lfZzlaHL z%qW{b=G@|b#2?$3nvo0>P4GXbW>KRH0cWNm#$=1`PmG3WG|Rr%7TQHJm-*UDzxVyV z_j&JqKA-o}Mt75gr}$xtA0Zp~TAo7aD2aSD!Q@I`enAjSj&$<|K~Q>$&SQLf3DJa3 zL_BN3I>|{BD2K&54&|{DGO!rsCVus-9r|#{#5N)$Ljrz|%zmJ7Y~J z8IWa`EJCPva%UR+43UJUSQ43~4z9M*lz!MkpFp%7rMs;k1#>fVxP~^g)XQBYn5;*V z?v0XWsdTB*x^B;c{57rP^y&@166Vu&AAYt{xV%xjyJSFPX}+|wDR29oV)s{vB|ToR z)2zC4s&zDPU^KEjM_$%)B+yb`zn(_0;z^Q!Ks4|+mFN)y0i6^h(dit*ak{lJx)EkE zW?}?q10R|2qywcaaKy13P!9s3EXZcS!vV>VMI^);h|^dJ(-P7WNYWlc1j`jt0ID`h z6??f13A zm-KtJj)Hz`L1o&K4yyi#KK>ZGeAcntcw_s?yKTprhwogKE9T#7-goF^jqdY7vgR7a z*e}v2Szo_nPpx~tO!EiQ8u&FTS--_yIptFAh@ZHCIsDWG7G$2gRHLG2u>D71 zoX4z%nsm`F%J&y5slIh#q?fc6U{#LdB&`MMSxjX}^d`!g&5A(3wh#EjhyiwWz%mC9 z*c##rFti9ftITt;7<2)riePvV3||M<&xeW;-ULABCG9Ark3zBz%*;Wo7I7h;5Fq#8 z3_NE>fJs->ICc zyiz#!UE}p;$BOoqzYa?4raA`>H{?3YKF(S8$@$e^-`+9rbpP?w`~Mi+FZAFi&H;p(nuQGZ1MKh8`~2G#WGAwC)& zb=S}T_Q1lcrl{eqQ}ewOt5=+ljJa{ycwb zj-0J~bLhuQEk>2CPJT@T+)@Cxs5%p-s}K3ZrC}w~6ZT~5vMpPcP}uM73G{@r_#Bfz z)Zy>;dp&SSO}vW zQ5tNV0pv+28m^=p#^@qkJ*~t%(Bu`jvJt!lA2{(UV%{u8;k2gcT*k}Q zbC4}&)1GdDcG?^^I}%D>>Ji=&uz}gOM3smw)U(ajr9?ckC*lz%$X;_~M^G_WnZuD# z)EhBd%|5>pki+Jx4ZY@WPgkrIHy+dyedV5Ldq9Er?r0$3QNt=2tys;|z~-vnUAwGF zfS6bR|M-OSUjyJZ7oeW6e3g~Xh3(~vue{vplRandom Forest learning algorithm for - * classification. - * It supports both binary and multiclass labels, as well as both continuous and categorical - * features. - */ -final class TypedRandomForestClassifier[Inputs] private[ml]( - rf: RandomForestClassifier, - labelCol: String, - featuresCol: String -) extends TypedEstimator[Inputs, TypedRandomForestClassifier.Outputs, RandomForestClassificationModel] { - - val estimator: RandomForestClassifier = - rf - .setLabelCol(labelCol) - .setFeaturesCol(featuresCol) - .setPredictionCol(AppendTransformer.tempColumnName) - .setRawPredictionCol(AppendTransformer.tempColumnName2) - .setProbabilityCol(AppendTransformer.tempColumnName3) - - def setNumTrees(value: Int): TypedRandomForestClassifier[Inputs] = copy(rf.setNumTrees(value)) - def setMaxDepth(value: Int): TypedRandomForestClassifier[Inputs] = copy(rf.setMaxDepth(value)) - def setMinInfoGain(value: Double): TypedRandomForestClassifier[Inputs] = copy(rf.setMinInfoGain(value)) - def setMinInstancesPerNode(value: Int): TypedRandomForestClassifier[Inputs] = copy(rf.setMinInstancesPerNode(value)) - def setMaxMemoryInMB(value: Int): TypedRandomForestClassifier[Inputs] = copy(rf.setMaxMemoryInMB(value)) - def setSubsamplingRate(value: Double): TypedRandomForestClassifier[Inputs] = copy(rf.setSubsamplingRate(value)) - def setFeatureSubsetStrategy(value: FeatureSubsetStrategy): TypedRandomForestClassifier[Inputs] = - copy(rf.setFeatureSubsetStrategy(value.sparkValue)) - def setMaxBins(value: Int): TypedRandomForestClassifier[Inputs] = copy(rf.setMaxBins(value)) - - private def copy(newRf: RandomForestClassifier): TypedRandomForestClassifier[Inputs] = - new TypedRandomForestClassifier[Inputs](newRf, labelCol, featuresCol) -} - -object TypedRandomForestClassifier { - case class Outputs(rawPrediction: Vector, probability: Vector, prediction: Double) - - def apply[Inputs](implicit inputsChecker: TreesInputsChecker[Inputs]): TypedRandomForestClassifier[Inputs] = { - new TypedRandomForestClassifier(new RandomForestClassifier(), inputsChecker.labelCol, inputsChecker.featuresCol) - } -} - diff --git a/ml/src/main/scala/frameless/ml/clustering/TypedBisectingKMeans.scala b/ml/src/main/scala/frameless/ml/clustering/TypedBisectingKMeans.scala deleted file mode 100644 index 4a8c974b4..000000000 --- a/ml/src/main/scala/frameless/ml/clustering/TypedBisectingKMeans.scala +++ /dev/null @@ -1,49 +0,0 @@ -package frameless -package ml -package classification - -import frameless.ml.internals.VectorInputsChecker -import org.apache.spark.ml.clustering.{BisectingKMeans, BisectingKMeansModel} - -/** - * A bisecting k-means algorithm based on the paper "A comparison of document clustering techniques" - * by Steinbach, Karypis, and Kumar, with modification to fit Spark. - * The algorithm starts from a single cluster that contains all points. - * Iteratively it finds divisible clusters on the bottom level and bisects each of them using - * k-means, until there are `k` leaf clusters in total or no leaf clusters are divisible. - * The bisecting steps of clusters on the same level are grouped together to increase parallelism. - * If bisecting all divisible clusters on the bottom level would result more than `k` leaf clusters, - * larger clusters get higher priority. - * - * @see - * Steinbach, Karypis, and Kumar, A comparison of document clustering techniques, - * KDD Workshop on Text Mining, 2000. - */ -class TypedBisectingKMeans[Inputs] private[ml] ( - bkm: BisectingKMeans, - featuresCol: String -) extends TypedEstimator[Inputs,TypedBisectingKMeans.Output, BisectingKMeansModel]{ - val estimator: BisectingKMeans = - bkm - .setFeaturesCol(featuresCol) - .setPredictionCol(AppendTransformer.tempColumnName) - - def setK(value: Int): TypedBisectingKMeans[Inputs] = copy(bkm.setK(value)) - - def setMaxIter(value: Int): TypedBisectingKMeans[Inputs] = copy(bkm.setMaxIter(value)) - - def setMinDivisibleClusterSize(value: Double): TypedBisectingKMeans[Inputs] = - copy(bkm.setMinDivisibleClusterSize(value)) - - def setSeed(value: Long): TypedBisectingKMeans[Inputs] = copy(bkm.setSeed(value)) - - private def copy(newBkm: BisectingKMeans): TypedBisectingKMeans[Inputs] = - new TypedBisectingKMeans[Inputs](newBkm, featuresCol) -} - -object TypedBisectingKMeans { - case class Output(prediction: Int) - - def apply[Inputs]()(implicit inputsChecker: VectorInputsChecker[Inputs]): TypedBisectingKMeans[Inputs] = - new TypedBisectingKMeans(new BisectingKMeans(), inputsChecker.featuresCol) -} \ No newline at end of file diff --git a/ml/src/main/scala/frameless/ml/clustering/TypedKMeans.scala b/ml/src/main/scala/frameless/ml/clustering/TypedKMeans.scala deleted file mode 100644 index 1a32076a5..000000000 --- a/ml/src/main/scala/frameless/ml/clustering/TypedKMeans.scala +++ /dev/null @@ -1,45 +0,0 @@ -package frameless -package ml -package classification - -import frameless.ml.internals.VectorInputsChecker -import frameless.ml.params.kmeans.KMeansInitMode -import org.apache.spark.ml.clustering.{KMeans, KMeansModel} - -/** - * K-means clustering with support for k-means|| initialization proposed by Bahmani et al. - * - * @see Bahmani et al., Scalable k-means++. - */ -class TypedKMeans[Inputs] private[ml] ( - km: KMeans, - featuresCol: String -) extends TypedEstimator[Inputs,TypedKMeans.Output,KMeansModel] { - val estimator: KMeans = - km - .setFeaturesCol(featuresCol) - .setPredictionCol(AppendTransformer.tempColumnName) - - def setK(value: Int): TypedKMeans[Inputs] = copy(km.setK(value)) - - def setInitMode(value: KMeansInitMode): TypedKMeans[Inputs] = copy(km.setInitMode(value.sparkValue)) - - def setInitSteps(value: Int): TypedKMeans[Inputs] = copy(km.setInitSteps(value)) - - def setMaxIter(value: Int): TypedKMeans[Inputs] = copy(km.setMaxIter(value)) - - def setTol(value: Double): TypedKMeans[Inputs] = copy(km.setTol(value)) - - def setSeed(value: Long): TypedKMeans[Inputs] = copy(km.setSeed(value)) - - private def copy(newKmeans: KMeans): TypedKMeans[Inputs] = new TypedKMeans[Inputs](newKmeans, featuresCol) - -} - -object TypedKMeans{ - case class Output(prediction: Int) - - def apply[Inputs](implicit inputsChecker: VectorInputsChecker[Inputs]): TypedKMeans[Inputs] = { - new TypedKMeans(new KMeans(), inputsChecker.featuresCol) - } -} diff --git a/ml/src/main/scala/frameless/ml/feature/TypedIndexToString.scala b/ml/src/main/scala/frameless/ml/feature/TypedIndexToString.scala deleted file mode 100644 index af2e9684a..000000000 --- a/ml/src/main/scala/frameless/ml/feature/TypedIndexToString.scala +++ /dev/null @@ -1,32 +0,0 @@ -package frameless -package ml -package feature - -import frameless.ml.internals.UnaryInputsChecker -import org.apache.spark.ml.feature.IndexToString - -/** - * A `TypedTransformer` that maps a column of indices back to a new column of corresponding - * string values. - * The index-string mapping must be supplied when creating the `TypedIndexToString`. - * - * @see `TypedStringIndexer` for converting strings into indices - */ -final class TypedIndexToString[Inputs] private[ml](indexToString: IndexToString, inputCol: String) - extends AppendTransformer[Inputs, TypedIndexToString.Outputs, IndexToString] { - - val transformer: IndexToString = - indexToString - .setInputCol(inputCol) - .setOutputCol(AppendTransformer.tempColumnName) - -} - -object TypedIndexToString { - case class Outputs(originalOutput: String) - - def apply[Inputs](labels: Array[String]) - (implicit inputsChecker: UnaryInputsChecker[Inputs, Double]): TypedIndexToString[Inputs] = { - new TypedIndexToString[Inputs](new IndexToString().setLabels(labels), inputsChecker.inputCol) - } -} \ No newline at end of file diff --git a/ml/src/main/scala/frameless/ml/feature/TypedStringIndexer.scala b/ml/src/main/scala/frameless/ml/feature/TypedStringIndexer.scala deleted file mode 100644 index 7eba8e306..000000000 --- a/ml/src/main/scala/frameless/ml/feature/TypedStringIndexer.scala +++ /dev/null @@ -1,42 +0,0 @@ -package frameless -package ml -package feature - -import frameless.ml.feature.TypedStringIndexer.HandleInvalid -import frameless.ml.internals.UnaryInputsChecker -import org.apache.spark.ml.feature.{StringIndexer, StringIndexerModel} - -/** - * A label indexer that maps a string column of labels to an ML column of label indices. - * The indices are in [0, numLabels), ordered by label frequencies. - * So the most frequent label gets index 0. - * - * @see `TypedIndexToString` for the inverse transformation - */ -final class TypedStringIndexer[Inputs] private[ml](stringIndexer: StringIndexer, inputCol: String) - extends TypedEstimator[Inputs, TypedStringIndexer.Outputs, StringIndexerModel] { - - val estimator: StringIndexer = stringIndexer - .setInputCol(inputCol) - .setOutputCol(AppendTransformer.tempColumnName) - - def setHandleInvalid(value: HandleInvalid): TypedStringIndexer[Inputs] = copy(stringIndexer.setHandleInvalid(value.sparkValue)) - - private def copy(newStringIndexer: StringIndexer): TypedStringIndexer[Inputs] = - new TypedStringIndexer[Inputs](newStringIndexer, inputCol) -} - -object TypedStringIndexer { - case class Outputs(indexedOutput: Double) - - sealed abstract class HandleInvalid(val sparkValue: String) - object HandleInvalid { - case object Error extends HandleInvalid("error") - case object Skip extends HandleInvalid("skip") - case object Keep extends HandleInvalid("keep") - } - - def apply[Inputs](implicit inputsChecker: UnaryInputsChecker[Inputs, String]): TypedStringIndexer[Inputs] = { - new TypedStringIndexer[Inputs](new StringIndexer(), inputsChecker.inputCol) - } -} \ No newline at end of file diff --git a/ml/src/main/scala/frameless/ml/feature/TypedVectorAssembler.scala b/ml/src/main/scala/frameless/ml/feature/TypedVectorAssembler.scala deleted file mode 100644 index b2e3d6f07..000000000 --- a/ml/src/main/scala/frameless/ml/feature/TypedVectorAssembler.scala +++ /dev/null @@ -1,69 +0,0 @@ -package frameless -package ml -package feature - -import org.apache.spark.ml.feature.VectorAssembler -import org.apache.spark.ml.linalg.Vector -import shapeless.{HList, HNil, LabelledGeneric} -import shapeless.ops.hlist.ToTraversable -import shapeless.ops.record.{Keys, Values} -import shapeless._ -import scala.annotation.implicitNotFound - -/** - * A feature transformer that merges multiple columns into a vector column. - */ -final class TypedVectorAssembler[Inputs] private[ml](vectorAssembler: VectorAssembler, inputCols: Array[String]) - extends AppendTransformer[Inputs, TypedVectorAssembler.Output, VectorAssembler] { - - val transformer: VectorAssembler = vectorAssembler - .setInputCols(inputCols) - .setOutputCol(AppendTransformer.tempColumnName) - -} - -object TypedVectorAssembler { - case class Output(vector: Vector) - - def apply[Inputs](implicit inputsChecker: TypedVectorAssemblerInputsChecker[Inputs]): TypedVectorAssembler[Inputs] = { - new TypedVectorAssembler(new VectorAssembler(), inputsChecker.inputCols.toArray) - } -} - -@implicitNotFound( - msg = "Cannot prove that ${Inputs} is a valid input type. Input type must only contain fields of numeric or boolean types." -) -private[ml] trait TypedVectorAssemblerInputsChecker[Inputs] { - val inputCols: Seq[String] -} - -private[ml] object TypedVectorAssemblerInputsChecker { - implicit def checkInputs[Inputs, InputsRec <: HList, InputsKeys <: HList, InputsVals <: HList]( - implicit - inputsGen: LabelledGeneric.Aux[Inputs, InputsRec], - inputsKeys: Keys.Aux[InputsRec, InputsKeys], - inputsKeysTraverse: ToTraversable.Aux[InputsKeys, Seq, Symbol], - inputsValues: Values.Aux[InputsRec, InputsVals], - inputsTypeCheck: TypedVectorAssemblerInputsValueChecker[InputsVals] - ): TypedVectorAssemblerInputsChecker[Inputs] = new TypedVectorAssemblerInputsChecker[Inputs] { - val inputCols: Seq[String] = inputsKeys.apply.to[Seq].map(_.name) - } -} - -private[ml] trait TypedVectorAssemblerInputsValueChecker[InputsVals] - -private[ml] object TypedVectorAssemblerInputsValueChecker { - implicit def hnilCheckInputsValue: TypedVectorAssemblerInputsValueChecker[HNil] = - new TypedVectorAssemblerInputsValueChecker[HNil] {} - - implicit def hlistCheckInputsValueNumeric[H, T <: HList]( - implicit ch: CatalystNumeric[H], - tt: TypedVectorAssemblerInputsValueChecker[T] - ): TypedVectorAssemblerInputsValueChecker[H :: T] = new TypedVectorAssemblerInputsValueChecker[H :: T] {} - - implicit def hlistCheckInputsValueBoolean[T <: HList]( - implicit tt: TypedVectorAssemblerInputsValueChecker[T] - ): TypedVectorAssemblerInputsValueChecker[Boolean :: T] = new TypedVectorAssemblerInputsValueChecker[Boolean :: T] {} -} - - diff --git a/ml/src/main/scala/frameless/ml/internals/LinearInputsChecker.scala b/ml/src/main/scala/frameless/ml/internals/LinearInputsChecker.scala deleted file mode 100644 index 995a3f961..000000000 --- a/ml/src/main/scala/frameless/ml/internals/LinearInputsChecker.scala +++ /dev/null @@ -1,70 +0,0 @@ -package frameless -package ml -package internals - -import org.apache.spark.ml.linalg._ -import shapeless.ops.hlist.Length -import shapeless.{HList, LabelledGeneric, Nat, Witness} - -import scala.annotation.implicitNotFound - -/** - * Can be used for linear reg algorithm - */ -@implicitNotFound( - msg = "Cannot prove that ${Inputs} is a valid input type. " + - "Input type must only contain a field of type Double (the label) and a field of type " + - "org.apache.spark.ml.linalg.Vector (the features) and optional field of float type (weight)." -) -trait LinearInputsChecker[Inputs] { - val featuresCol: String - val labelCol: String - val weightCol: Option[String] -} - -object LinearInputsChecker { - - implicit def checkLinearInputs[ - Inputs, - InputsRec <: HList, - LabelK <: Symbol, - FeaturesK <: Symbol]( - implicit - i0: LabelledGeneric.Aux[Inputs, InputsRec], - i1: Length.Aux[InputsRec, Nat._2], - i2: SelectorByValue.Aux[InputsRec, Double, LabelK], - i3: Witness.Aux[LabelK], - i4: SelectorByValue.Aux[InputsRec, Vector, FeaturesK], - i5: Witness.Aux[FeaturesK] - ): LinearInputsChecker[Inputs] = { - new LinearInputsChecker[Inputs] { - val labelCol: String = implicitly[Witness.Aux[LabelK]].value.name - val featuresCol: String = implicitly[Witness.Aux[FeaturesK]].value.name - val weightCol: Option[String] = None - } - } - - implicit def checkLinearInputs2[ - Inputs, - InputsRec <: HList, - LabelK <: Symbol, - FeaturesK <: Symbol, - WeightK <: Symbol]( - implicit - i0: LabelledGeneric.Aux[Inputs, InputsRec], - i1: Length.Aux[InputsRec, Nat._3], - i2: SelectorByValue.Aux[InputsRec, Vector, FeaturesK], - i3: Witness.Aux[FeaturesK], - i4: SelectorByValue.Aux[InputsRec, Double, LabelK], - i5: Witness.Aux[LabelK], - i6: SelectorByValue.Aux[InputsRec, Float, WeightK], - i7: Witness.Aux[WeightK] - ): LinearInputsChecker[Inputs] = { - new LinearInputsChecker[Inputs] { - val labelCol: String = implicitly[Witness.Aux[LabelK]].value.name - val featuresCol: String = implicitly[Witness.Aux[FeaturesK]].value.name - val weightCol: Option[String] = Some(implicitly[Witness.Aux[WeightK]].value.name) - } - } - -} diff --git a/ml/src/main/scala/frameless/ml/internals/SelectorByValue.scala b/ml/src/main/scala/frameless/ml/internals/SelectorByValue.scala deleted file mode 100644 index 9a67d5299..000000000 --- a/ml/src/main/scala/frameless/ml/internals/SelectorByValue.scala +++ /dev/null @@ -1,29 +0,0 @@ -package frameless -package ml -package internals - -import shapeless.labelled.FieldType -import shapeless.{::, DepFn1, HList, Witness} - -/** - * Typeclass supporting record selection by value type (returning the first key whose value is of type `Value`) - */ -trait SelectorByValue[L <: HList, Value] extends DepFn1[L] with Serializable { type Out <: Symbol } - -object SelectorByValue { - type Aux[L <: HList, Value, Out0 <: Symbol] = SelectorByValue[L, Value] { type Out = Out0 } - - implicit def select[K <: Symbol, T <: HList, Value](implicit wk: Witness.Aux[K]): Aux[FieldType[K, Value] :: T, Value, K] = { - new SelectorByValue[FieldType[K, Value] :: T, Value] { - type Out = K - def apply(l: FieldType[K, Value] :: T): Out = wk.value - } - } - - implicit def recurse[H, T <: HList, Value](implicit st: SelectorByValue[T, Value]): Aux[H :: T, Value, st.Out] = { - new SelectorByValue[H :: T, Value] { - type Out = st.Out - def apply(l: H :: T): Out = st(l.tail) - } - } -} diff --git a/ml/src/main/scala/frameless/ml/internals/TreesInputsChecker.scala b/ml/src/main/scala/frameless/ml/internals/TreesInputsChecker.scala deleted file mode 100644 index 0fe157654..000000000 --- a/ml/src/main/scala/frameless/ml/internals/TreesInputsChecker.scala +++ /dev/null @@ -1,45 +0,0 @@ -package frameless -package ml -package internals - -import shapeless.ops.hlist.Length -import shapeless.{HList, LabelledGeneric, Nat, Witness} -import org.apache.spark.ml.linalg._ - -import scala.annotation.implicitNotFound - -/** - * Can be used for all tree-based ML algorithm (decision tree, random forest, gradient-boosted trees) - */ -@implicitNotFound( - msg = "Cannot prove that ${Inputs} is a valid input type. " + - "Input type must only contain a field of type Double (the label) and a field of type " + - "org.apache.spark.ml.linalg.Vector (the features)." -) -trait TreesInputsChecker[Inputs] { - val featuresCol: String - val labelCol: String -} - -object TreesInputsChecker { - - implicit def checkTreesInputs[ - Inputs, - InputsRec <: HList, - LabelK <: Symbol, - FeaturesK <: Symbol]( - implicit - i0: LabelledGeneric.Aux[Inputs, InputsRec], - i1: Length.Aux[InputsRec, Nat._2], - i2: SelectorByValue.Aux[InputsRec, Double, LabelK], - i3: Witness.Aux[LabelK], - i4: SelectorByValue.Aux[InputsRec, Vector, FeaturesK], - i5: Witness.Aux[FeaturesK] - ): TreesInputsChecker[Inputs] = { - new TreesInputsChecker[Inputs] { - val labelCol: String = implicitly[Witness.Aux[LabelK]].value.name - val featuresCol: String = implicitly[Witness.Aux[FeaturesK]].value.name - } - } - -} diff --git a/ml/src/main/scala/frameless/ml/internals/UnaryInputsChecker.scala b/ml/src/main/scala/frameless/ml/internals/UnaryInputsChecker.scala deleted file mode 100644 index 56dfc9a57..000000000 --- a/ml/src/main/scala/frameless/ml/internals/UnaryInputsChecker.scala +++ /dev/null @@ -1,33 +0,0 @@ -package frameless -package ml -package internals - -import shapeless.ops.hlist.Length -import shapeless.{HList, LabelledGeneric, Nat, Witness} - -import scala.annotation.implicitNotFound - -/** - * Can be used for all unary transformers (i.e almost all of them) - */ -@implicitNotFound( - msg = "Cannot prove that ${Inputs} is a valid input type. Input type must have only one field of type ${Expected}" -) -trait UnaryInputsChecker[Inputs, Expected] { - val inputCol: String -} - -object UnaryInputsChecker { - - implicit def checkUnaryInputs[Inputs, Expected, InputsRec <: HList, InputK <: Symbol]( - implicit - i0: LabelledGeneric.Aux[Inputs, InputsRec], - i1: Length.Aux[InputsRec, Nat._1], - i2: SelectorByValue.Aux[InputsRec, Expected, InputK], - i3: Witness.Aux[InputK] - ): UnaryInputsChecker[Inputs, Expected] = new UnaryInputsChecker[Inputs, Expected] { - val inputCol: String = implicitly[Witness.Aux[InputK]].value.name - } - -} - diff --git a/ml/src/main/scala/frameless/ml/internals/VectorInputsChecker.scala b/ml/src/main/scala/frameless/ml/internals/VectorInputsChecker.scala deleted file mode 100644 index e993d9a55..000000000 --- a/ml/src/main/scala/frameless/ml/internals/VectorInputsChecker.scala +++ /dev/null @@ -1,32 +0,0 @@ -package frameless -package ml -package internals - -import shapeless.ops.hlist.Length -import shapeless.{HList, LabelledGeneric, Nat, Witness} - -import scala.annotation.implicitNotFound -import org.apache.spark.ml.linalg.Vector - -/** Can be used whenever algorithm requires only vector */ -@implicitNotFound( - msg = "Cannot prove that ${Inputs} is a valid input type. " + - "Input type must only contain a field of type org.apache.spark.ml.linalg.Vector (the features)." -) -trait VectorInputsChecker[Inputs] { - val featuresCol: String -} - -object VectorInputsChecker { - implicit def checkVectorInput[Inputs, InputsRec <: HList, FeaturesK <: Symbol]( - implicit - i0: LabelledGeneric.Aux[Inputs, InputsRec], - i1: Length.Aux[InputsRec, Nat._1], - i2: SelectorByValue.Aux[InputsRec, Vector, FeaturesK], - i3: Witness.Aux[FeaturesK] - ): VectorInputsChecker[Inputs] = { - new VectorInputsChecker[Inputs] { - val featuresCol: String = i3.value.name - } - } -} diff --git a/ml/src/main/scala/frameless/ml/package.scala b/ml/src/main/scala/frameless/ml/package.scala deleted file mode 100644 index d1c306158..000000000 --- a/ml/src/main/scala/frameless/ml/package.scala +++ /dev/null @@ -1,13 +0,0 @@ -package frameless - -import org.apache.spark.sql.FramelessInternals.UserDefinedType -import org.apache.spark.ml.FramelessInternals -import org.apache.spark.ml.linalg.{Matrix, Vector} - -package object ml { - - implicit val mlVectorUdt: UserDefinedType[Vector] = FramelessInternals.vectorUdt - - implicit val mlMatrixUdt: UserDefinedType[Matrix] = FramelessInternals.matrixUdt - -} diff --git a/ml/src/main/scala/frameless/ml/params/kmeans/KMeansInitMode.scala b/ml/src/main/scala/frameless/ml/params/kmeans/KMeansInitMode.scala deleted file mode 100644 index b3c023735..000000000 --- a/ml/src/main/scala/frameless/ml/params/kmeans/KMeansInitMode.scala +++ /dev/null @@ -1,19 +0,0 @@ -package frameless -package ml -package params -package kmeans - -/** - * Param for the initialization algorithm. - * This can be either "random" to choose random points as - * initial cluster centers, or "k-means||" to use a parallel variant of k-means++ - * (Bahmani et al., Scalable K-Means++, VLDB 2012). - * Default: k-means||. - */ - -sealed abstract class KMeansInitMode private[ml](val sparkValue: String) - -object KMeansInitMode { - case object Random extends KMeansInitMode("random") - case object KMeansPlusPlus extends KMeansInitMode("k-means||") -} diff --git a/ml/src/main/scala/frameless/ml/params/linears/LossStrategy.scala b/ml/src/main/scala/frameless/ml/params/linears/LossStrategy.scala deleted file mode 100644 index 4b9ca6d4e..000000000 --- a/ml/src/main/scala/frameless/ml/params/linears/LossStrategy.scala +++ /dev/null @@ -1,16 +0,0 @@ -package frameless -package ml -package params -package linears -/** - * SquaredError measures the average of the squares of the errors—that is, - * the average squared difference between the estimated values and what is estimated. - * - * Huber Loss loss function less sensitive to outliers in data than the - * squared error loss - */ -sealed abstract class LossStrategy private[ml](val sparkValue: String) -object LossStrategy { - case object SquaredError extends LossStrategy("squaredError") - case object Huber extends LossStrategy("huber") -} diff --git a/ml/src/main/scala/frameless/ml/params/linears/Solver.scala b/ml/src/main/scala/frameless/ml/params/linears/Solver.scala deleted file mode 100644 index 277e06e7a..000000000 --- a/ml/src/main/scala/frameless/ml/params/linears/Solver.scala +++ /dev/null @@ -1,25 +0,0 @@ -package frameless -package ml -package params -package linears - -/** - * solver algorithm used for optimization. - * - "l-bfgs" denotes Limited-memory BFGS which is a limited-memory quasi-Newton - * optimization method. - * - "normal" denotes using Normal Equation as an analytical solution to the linear regression - * problem. This solver is limited to `LinearRegression.MAX_FEATURES_FOR_NORMAL_SOLVER`. - * - "auto" (default) means that the solver algorithm is selected automatically. - * The Normal Equations solver will be used when possible, but this will automatically fall - * back to iterative optimization methods when needed. - * - * spark - */ - -sealed abstract class Solver private[ml](val sparkValue: String) -object Solver { - case object LBFGS extends Solver("l-bfgs") - case object Auto extends Solver("auto") - case object Normal extends Solver("normal") -} - diff --git a/ml/src/main/scala/frameless/ml/params/trees/FeatureSubsetStrategy.scala b/ml/src/main/scala/frameless/ml/params/trees/FeatureSubsetStrategy.scala deleted file mode 100644 index f2167f983..000000000 --- a/ml/src/main/scala/frameless/ml/params/trees/FeatureSubsetStrategy.scala +++ /dev/null @@ -1,39 +0,0 @@ -package frameless -package ml -package params -package trees -/** - * The number of features to consider for splits at each tree node. - * Supported options: - * - Auto: Choose automatically for task: - * If numTrees == 1, set to All - * If numTrees > 1 (forest), set to Sqrt for classification and - * to OneThird for regression. - * - All: use all features - * - OneThird: use 1/3 of the features - * - Sqrt: use sqrt(number of features) - * - Log2: use log2(number of features) - * - Ratio: use (ratio * number of features) features - * - NumberOfFeatures: use numberOfFeatures features. - * (default = Auto) - * - * These various settings are based on the following references: - * - log2: tested in Breiman (2001) - * - sqrt: recommended by Breiman manual for random forests - * - The defaults of sqrt (classification) and onethird (regression) match the R randomForest - * package. - * - * @see Breiman (2001) - * @see - * Breiman manual for random forests - */ -sealed abstract class FeatureSubsetStrategy private[ml](val sparkValue: String) -object FeatureSubsetStrategy { - case object Auto extends FeatureSubsetStrategy("auto") - case object All extends FeatureSubsetStrategy("all") - case object OneThird extends FeatureSubsetStrategy("onethird") - case object Sqrt extends FeatureSubsetStrategy("sqrt") - case object Log2 extends FeatureSubsetStrategy("log2") - case class Ratio(value: Double) extends FeatureSubsetStrategy(value.toString) - case class NumberOfFeatures(value: Int) extends FeatureSubsetStrategy(value.toString) -} \ No newline at end of file diff --git a/ml/src/main/scala/frameless/ml/regression/TypedLinearRegression.scala b/ml/src/main/scala/frameless/ml/regression/TypedLinearRegression.scala deleted file mode 100644 index 3b3208623..000000000 --- a/ml/src/main/scala/frameless/ml/regression/TypedLinearRegression.scala +++ /dev/null @@ -1,52 +0,0 @@ -package frameless -package ml -package regression - -import frameless.ml.internals.LinearInputsChecker -import frameless.ml.params.linears.{LossStrategy, Solver} -import frameless.ml.{AppendTransformer, TypedEstimator} -import org.apache.spark.ml.regression.{LinearRegression, LinearRegressionModel} - -/** - * Linear Regression linear approach to modelling the relationship - * between a scalar response (or dependent variable) and one or more explanatory variables - */ -final class TypedLinearRegression [Inputs] private[ml]( - lr: LinearRegression, - labelCol: String, - featuresCol: String, - weightCol: Option[String] -) extends TypedEstimator[Inputs, TypedLinearRegression.Outputs, LinearRegressionModel] { - - val estimatorWithoutWeight : LinearRegression = lr - .setLabelCol(labelCol) - .setFeaturesCol(featuresCol) - .setPredictionCol(AppendTransformer.tempColumnName) - - val estimator = if (weightCol.isDefined) estimatorWithoutWeight.setWeightCol(weightCol.get) else estimatorWithoutWeight - - def setRegParam(value: Double): TypedLinearRegression[Inputs] = copy(lr.setRegParam(value)) - def setFitIntercept(value: Boolean): TypedLinearRegression[Inputs] = copy(lr.setFitIntercept(value)) - def setStandardization(value: Boolean): TypedLinearRegression[Inputs] = copy(lr.setStandardization(value)) - def setElasticNetParam(value: Double): TypedLinearRegression[Inputs] = copy(lr.setElasticNetParam(value)) - def setMaxIter(value: Int): TypedLinearRegression[Inputs] = copy(lr.setMaxIter(value)) - def setTol(value: Double): TypedLinearRegression[Inputs] = copy(lr.setTol(value)) - def setSolver(value: Solver): TypedLinearRegression[Inputs] = copy(lr.setSolver(value.sparkValue)) - def setAggregationDepth(value: Int): TypedLinearRegression[Inputs] = copy(lr.setAggregationDepth(value)) - def setLoss(value: LossStrategy): TypedLinearRegression[Inputs] = copy(lr.setLoss(value.sparkValue)) - def setEpsilon(value: Double): TypedLinearRegression[Inputs] = copy(lr.setEpsilon(value)) - - private def copy(newLr: LinearRegression): TypedLinearRegression[Inputs] = - new TypedLinearRegression[Inputs](newLr, labelCol, featuresCol, weightCol) - -} - -object TypedLinearRegression { - case class Outputs(prediction: Double) - case class Weight(weight: Double) - - - def apply[Inputs](implicit inputsChecker: LinearInputsChecker[Inputs]): TypedLinearRegression[Inputs] = { - new TypedLinearRegression(new LinearRegression(), inputsChecker.labelCol, inputsChecker.featuresCol, inputsChecker.weightCol) - } -} \ No newline at end of file diff --git a/ml/src/main/scala/frameless/ml/regression/TypedRandomForestRegressor.scala b/ml/src/main/scala/frameless/ml/regression/TypedRandomForestRegressor.scala deleted file mode 100644 index 69c1ad68c..000000000 --- a/ml/src/main/scala/frameless/ml/regression/TypedRandomForestRegressor.scala +++ /dev/null @@ -1,47 +0,0 @@ -package frameless -package ml -package regression - -import frameless.ml.internals.TreesInputsChecker -import frameless.ml.params.trees.FeatureSubsetStrategy -import org.apache.spark.ml.regression.{RandomForestRegressionModel, RandomForestRegressor} - -/** - * Random Forest - * learning algorithm for regression. - * It supports both continuous and categorical features. - */ -final class TypedRandomForestRegressor[Inputs] private[ml]( - rf: RandomForestRegressor, - labelCol: String, - featuresCol: String -) extends TypedEstimator[Inputs, TypedRandomForestRegressor.Outputs, RandomForestRegressionModel] { - - val estimator: RandomForestRegressor = - rf - .setLabelCol(labelCol) - .setFeaturesCol(featuresCol) - .setPredictionCol(AppendTransformer.tempColumnName) - - def setNumTrees(value: Int): TypedRandomForestRegressor[Inputs] = copy(rf.setNumTrees(value)) - def setMaxDepth(value: Int): TypedRandomForestRegressor[Inputs] = copy(rf.setMaxDepth(value)) - def setMinInfoGain(value: Double): TypedRandomForestRegressor[Inputs] = copy(rf.setMinInfoGain(value)) - def setMinInstancesPerNode(value: Int): TypedRandomForestRegressor[Inputs] = copy(rf.setMinInstancesPerNode(value)) - def setMaxMemoryInMB(value: Int): TypedRandomForestRegressor[Inputs] = copy(rf.setMaxMemoryInMB(value)) - def setSubsamplingRate(value: Double): TypedRandomForestRegressor[Inputs] = copy(rf.setSubsamplingRate(value)) - def setFeatureSubsetStrategy(value: FeatureSubsetStrategy): TypedRandomForestRegressor[Inputs] = - copy(rf.setFeatureSubsetStrategy(value.sparkValue)) - def setMaxBins(value: Int): TypedRandomForestRegressor[Inputs] = copy(rf.setMaxBins(value)) - - private def copy(newRf: RandomForestRegressor): TypedRandomForestRegressor[Inputs] = - new TypedRandomForestRegressor[Inputs](newRf, labelCol, featuresCol) -} - -object TypedRandomForestRegressor { - case class Outputs(prediction: Double) - - def apply[Inputs](implicit inputsChecker: TreesInputsChecker[Inputs]) - : TypedRandomForestRegressor[Inputs] = { - new TypedRandomForestRegressor(new RandomForestRegressor(), inputsChecker.labelCol, inputsChecker.featuresCol) - } -} \ No newline at end of file diff --git a/ml/src/main/scala/org/apache/spark/ml/FramelessInternals.scala b/ml/src/main/scala/org/apache/spark/ml/FramelessInternals.scala deleted file mode 100644 index bec43cd11..000000000 --- a/ml/src/main/scala/org/apache/spark/ml/FramelessInternals.scala +++ /dev/null @@ -1,13 +0,0 @@ -package org.apache.spark.ml - -import org.apache.spark.ml.linalg.{MatrixUDT, VectorUDT} - -object FramelessInternals { - - // because org.apache.spark.ml.linalg.VectorUDT is private[spark] - val vectorUdt = new VectorUDT - - // because org.apache.spark.ml.linalg.MatrixUDT is private[spark] - val matrixUdt = new MatrixUDT - -} diff --git a/ml/src/test/scala/frameless/ml/FramelessMlSuite.scala b/ml/src/test/scala/frameless/ml/FramelessMlSuite.scala deleted file mode 100644 index de8fcab56..000000000 --- a/ml/src/test/scala/frameless/ml/FramelessMlSuite.scala +++ /dev/null @@ -1,14 +0,0 @@ -package frameless -package ml - -import org.scalactic.anyvals.PosZInt -import org.scalatest.BeforeAndAfterAll -import org.scalatestplus.scalacheck.Checkers -import org.scalatest.funsuite.AnyFunSuite - -class FramelessMlSuite extends AnyFunSuite with Checkers with BeforeAndAfterAll with SparkTesting { - // Limit size of generated collections and number of checks because Travis - implicit override val generatorDrivenConfig = - PropertyCheckConfiguration(sizeRange = PosZInt(10), minSize = PosZInt(10)) - implicit val sparkDelay: SparkDelay[Job] = Job.framelessSparkDelayForJob -} diff --git a/ml/src/test/scala/frameless/ml/Generators.scala b/ml/src/test/scala/frameless/ml/Generators.scala deleted file mode 100644 index 9a109e154..000000000 --- a/ml/src/test/scala/frameless/ml/Generators.scala +++ /dev/null @@ -1,57 +0,0 @@ -package frameless -package ml - -import frameless.ml.params.linears.{LossStrategy, Solver} -import frameless.ml.params.trees.FeatureSubsetStrategy -import org.apache.spark.ml.linalg.{Matrices, Matrix, Vector, Vectors} -import org.scalacheck.{Arbitrary, Gen} - -object Generators { - - implicit val arbVector: Arbitrary[Vector] = Arbitrary { - val genDenseVector = Gen.listOf(arbDouble.arbitrary).map(doubles => Vectors.dense(doubles.toArray)) - val genSparseVector = genDenseVector.map(_.toSparse) - - Gen.oneOf(genDenseVector, genSparseVector) - } - - implicit val arbMatrix: Arbitrary[Matrix] = Arbitrary { - Gen.sized { size => - for { - nbRows <- Gen.choose(0, size) - nbCols <- Gen.choose(1, size) - matrix <- { - Gen.listOfN(nbRows * nbCols, arbDouble.arbitrary) - .map(values => Matrices.dense(nbRows, nbCols, values.toArray)) - } - } yield matrix - } - } - - implicit val arbTreesFeaturesSubsetStrategy: Arbitrary[FeatureSubsetStrategy] = Arbitrary { - val genRatio = Gen.choose(0D, 1D).suchThat(_ > 0D).map(FeatureSubsetStrategy.Ratio) - val genNumberOfFeatures = Gen.choose(1, Int.MaxValue).map(FeatureSubsetStrategy.NumberOfFeatures) - - Gen.oneOf(Gen.const(FeatureSubsetStrategy.All), - Gen.const(FeatureSubsetStrategy.All), - Gen.const(FeatureSubsetStrategy.Log2), - Gen.const(FeatureSubsetStrategy.OneThird), - Gen.const(FeatureSubsetStrategy.Sqrt), - genRatio, - genNumberOfFeatures - ) - } - - implicit val arbLossStrategy: Arbitrary[LossStrategy] = Arbitrary { - Gen.const(LossStrategy.SquaredError) - } - - implicit val arbSolver: Arbitrary[Solver] = Arbitrary { - Gen.oneOf( - Gen.const(Solver.LBFGS), - Gen.const(Solver.Auto), - Gen.const(Solver.Normal) - ) - } - -} diff --git a/ml/src/test/scala/frameless/ml/TypedEncoderInstancesTests.scala b/ml/src/test/scala/frameless/ml/TypedEncoderInstancesTests.scala deleted file mode 100644 index 350c5ca49..000000000 --- a/ml/src/test/scala/frameless/ml/TypedEncoderInstancesTests.scala +++ /dev/null @@ -1,55 +0,0 @@ -package frameless -package ml - -import org.scalacheck.Prop._ -import org.apache.spark.ml.linalg._ -import org.apache.spark.ml.regression.DecisionTreeRegressor -import Generators._ -import scala.util.Random - -class TypedEncoderInstancesTests extends FramelessMlSuite { - - test("Vector encoding is injective using collect()") { - val prop = forAll { vector: Vector => - TypedDataset.create(Seq(vector)).collect().run() == Seq(vector) - } - check(prop) - } - - test("Matrix encoding is injective using collect()") { - val prop = forAll { matrix: Matrix => - TypedDataset.create(Seq(matrix)).collect().run() == Seq(matrix) - } - check(prop) - } - - test("Vector is encoded as VectorUDT and thus can be run in a Spark ML model") { - case class Input(features: Vector, label: Double) - - val prop = forAll { trainingData: Matrix => - (trainingData.numRows >= 1) ==> { - val inputs = trainingData.rowIter.toVector.map(vector => Input(vector, 0D)) - val inputsDS = TypedDataset.create(inputs) - - val model = new DecisionTreeRegressor() - - // this line would throw a runtime exception if Vector was not encoded as VectorUDT - val trainedModel = model.fit(inputsDS.dataset) - - val randomInput = inputs(Random.nextInt(inputs.length)) - val randomInputDS = TypedDataset.create(Seq(randomInput)) - - val prediction = trainedModel.transform(randomInputDS.dataset) - .select("prediction") - .head - .getAs[Double](0) - - prediction == 0D - } - - } - - check(prop, MinSize(1)) - } - -} diff --git a/ml/src/test/scala/frameless/ml/classification/ClassificationIntegrationTests.scala b/ml/src/test/scala/frameless/ml/classification/ClassificationIntegrationTests.scala deleted file mode 100644 index d32203887..000000000 --- a/ml/src/test/scala/frameless/ml/classification/ClassificationIntegrationTests.scala +++ /dev/null @@ -1,74 +0,0 @@ -package frameless -package ml -package classification - -import frameless.ml.feature.{TypedIndexToString, TypedStringIndexer, TypedVectorAssembler} -import org.apache.spark.ml.linalg.Vector -import org.scalatest.matchers.must.Matchers - -class ClassificationIntegrationTests extends FramelessMlSuite with Matchers { - - test("predict field3 from field1 and field2 using a RandomForestClassifier") { - case class Data(field1: Double, field2: Int, field3: String) - - // Training - - val trainingDataDs = TypedDataset.create(Seq.fill(10)(Data(0D, 10, "foo"))) - - case class Features(field1: Double, field2: Int) - val vectorAssembler = TypedVectorAssembler[Features] - - case class DataWithFeatures(field1: Double, field2: Int, field3: String, features: Vector) - val dataWithFeatures = vectorAssembler.transform(trainingDataDs).as[DataWithFeatures] - - case class StringIndexerInput(field3: String) - val indexer = TypedStringIndexer[StringIndexerInput] - val indexerModel = indexer.fit(dataWithFeatures).run() - - case class IndexedDataWithFeatures(field1: Double, field2: Int, field3: String, features: Vector, indexedField3: Double) - val indexedData = indexerModel.transform(dataWithFeatures).as[IndexedDataWithFeatures] - - case class RFInputs(indexedField3: Double, features: Vector) - val rf = TypedRandomForestClassifier[RFInputs] - - val model = rf.fit(indexedData).run() - - // Prediction - - val testData = TypedDataset.create(Seq( - Data(0D, 10, "foo") - )) - val testDataWithFeatures = vectorAssembler.transform(testData).as[DataWithFeatures] - val indexedTestData = indexerModel.transform(testDataWithFeatures).as[IndexedDataWithFeatures] - - case class PredictionInputs(features: Vector, indexedField3: Double) - val testInput = indexedTestData.project[PredictionInputs] - - case class PredictionResultIndexed( - features: Vector, - indexedField3: Double, - rawPrediction: Vector, - probability: Vector, - predictedField3Indexed: Double - ) - val predictionDs = model.transform(testInput).as[PredictionResultIndexed] - - case class IndexToStringInput(predictedField3Indexed: Double) - val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labelsArray.flatten) - - case class PredictionResult( - features: Vector, - indexedField3: Double, - rawPrediction: Vector, - probability: Vector, - predictedField3Indexed: Double, - predictedField3: String - ) - val stringPredictionDs = indexToString.transform(predictionDs).as[PredictionResult] - - val prediction = stringPredictionDs.select(stringPredictionDs.col('predictedField3)).collect.run().toList - - prediction mustEqual List("foo") - } - -} diff --git a/ml/src/test/scala/frameless/ml/classification/TypedRandomForestClassifierTests.scala b/ml/src/test/scala/frameless/ml/classification/TypedRandomForestClassifierTests.scala deleted file mode 100644 index e5ebafd2e..000000000 --- a/ml/src/test/scala/frameless/ml/classification/TypedRandomForestClassifierTests.scala +++ /dev/null @@ -1,89 +0,0 @@ -package frameless -package ml -package classification - -import shapeless.test.illTyped -import org.apache.spark.ml.linalg._ -import frameless.ml.params.trees.FeatureSubsetStrategy -import org.scalacheck.{Arbitrary, Gen} -import org.scalacheck.Prop._ -import org.scalatest.matchers.must.Matchers - -class TypedRandomForestClassifierTests extends FramelessMlSuite with Matchers { - implicit val arbDouble: Arbitrary[Double] = - Arbitrary(Gen.choose(1, 99).map(_.toDouble)) // num classes must be between 0 and 100 for the test - implicit val arbVectorNonEmpty: Arbitrary[Vector] = - Arbitrary(Generators.arbVector.arbitrary suchThat (_.size > 0)) // vector must not be empty for RandomForestClassifier - import Generators.arbTreesFeaturesSubsetStrategy - - test("fit() returns a correct TypedTransformer") { - val prop = forAll { x2: X2[Double, Vector] => - val rf = TypedRandomForestClassifier[X2[Double, Vector]] - val ds = TypedDataset.create(Seq(x2)) - val model = rf.fit(ds).run() - val pDs = model.transform(ds).as[X5[Double, Vector, Vector, Vector, Double]] - - pDs.select(pDs.col('a), pDs.col('b)).collect.run() == Seq(x2.a -> x2.b) - } - - val prop2 = forAll { x2: X2[Vector, Double] => - val rf = TypedRandomForestClassifier[X2[Vector, Double]] - val ds = TypedDataset.create(Seq(x2)) - val model = rf.fit(ds).run() - val pDs = model.transform(ds).as[X5[Vector, Double, Vector, Vector, Double]] - - pDs.select(pDs.col('a), pDs.col('b)).collect.run() == Seq(x2.a -> x2.b) - } - - def prop3[A: TypedEncoder: Arbitrary] = forAll { x3: X3[Vector, Double, A] => - val rf = TypedRandomForestClassifier[X2[Vector, Double]] - val ds = TypedDataset.create(Seq(x3)) - val model = rf.fit(ds).run() - val pDs = model.transform(ds).as[X6[Vector, Double, A, Vector, Vector, Double]] - - pDs.select(pDs.col('a), pDs.col('b), pDs.col('c)).collect.run() == Seq((x3.a, x3.b, x3.c)) - } - - check(prop) - check(prop2) - check(prop3[String]) - check(prop3[Double]) - } - - test("param setting is retained") { - val prop = forAll { featureSubsetStrategy: FeatureSubsetStrategy => - val rf = TypedRandomForestClassifier[X2[Double, Vector]] - .setNumTrees(10) - .setMaxBins(100) - .setFeatureSubsetStrategy(featureSubsetStrategy) - .setMaxDepth(10) - .setMaxMemoryInMB(100) - .setMinInfoGain(0.1D) - .setMinInstancesPerNode(2) - .setSubsamplingRate(0.9D) - - val ds = TypedDataset.create(Seq(X2(0D, Vectors.dense(0D)))) - val model = rf.fit(ds).run() - - model.transformer.getNumTrees == 10 && - model.transformer.getMaxBins == 100 && - model.transformer.getFeatureSubsetStrategy == featureSubsetStrategy.sparkValue && - model.transformer.getMaxDepth == 10 && - model.transformer.getMaxMemoryInMB == 100 && - model.transformer.getMinInfoGain == 0.1D && - model.transformer.getMinInstancesPerNode == 2 && - model.transformer.getSubsamplingRate == 0.9D - } - - check(prop) - } - - test("create() compiles only with correct inputs") { - illTyped("TypedRandomForestClassifier.create[Double]()") - illTyped("TypedRandomForestClassifier.create[X1[Double]]()") - illTyped("TypedRandomForestClassifier.create[X2[Double, Double]]()") - illTyped("TypedRandomForestClassifier.create[X3[Vector, Double, Int]]()") - illTyped("TypedRandomForestClassifier.create[X2[Vector, String]]()") - } - -} \ No newline at end of file diff --git a/ml/src/test/scala/frameless/ml/clustering/BisectingKMeansTests.scala b/ml/src/test/scala/frameless/ml/clustering/BisectingKMeansTests.scala deleted file mode 100644 index 970b3ea21..000000000 --- a/ml/src/test/scala/frameless/ml/clustering/BisectingKMeansTests.scala +++ /dev/null @@ -1,55 +0,0 @@ -package frameless -package ml -package clustering - -import frameless.{TypedDataset, TypedEncoder, X1, X2, X3} -import frameless.ml.classification.TypedBisectingKMeans -import org.scalacheck.Arbitrary -import org.apache.spark.ml.linalg._ -import org.scalacheck.Prop._ -import frameless.ml._ -import org.scalatest.matchers.must.Matchers - -class BisectingKMeansTests extends FramelessMlSuite with Matchers { - implicit val arbVector: Arbitrary[Vector] = - Arbitrary(Generators.arbVector.arbitrary) - - test("fit() returns a correct TypedTransformer") { - val prop = forAll { x1: X1[Vector] => - val km = TypedBisectingKMeans[X1[Vector]]() - val ds = TypedDataset.create(Seq(x1)) - val model = km.fit(ds).run() - val pDs = model.transform(ds).as[X2[Vector, Int]] - - pDs.select(pDs.col('a)).collect().run().toList == Seq(x1.a) - } - - def prop3[A: TypedEncoder : Arbitrary] = forAll { x2: X2[Vector, A] => - val km = TypedBisectingKMeans[X1[Vector]] - val ds = TypedDataset.create(Seq(x2)) - val model = km.fit(ds).run() - val pDs = model.transform(ds).as[X3[Vector, A, Int]] - - pDs.select(pDs.col('a), pDs.col('b)).collect.run() == Seq((x2.a, x2.b)) - } - - check(prop) - check(prop3[Double]) - } - - test("param setting is retained") { - val rf = TypedBisectingKMeans[X1[Vector]]() - .setK(10) - .setMaxIter(10) - .setMinDivisibleClusterSize(1) - .setSeed(123332) - - val ds = TypedDataset.create(Seq(X2(Vectors.dense(Array(0D)),0))) - val model = rf.fit(ds).run() - - model.transformer.getK == 10 && - model.transformer.getMaxIter == 10 && - model.transformer.getMinDivisibleClusterSize == 1 && - model.transformer.getSeed == 123332 - } -} diff --git a/ml/src/test/scala/frameless/ml/clustering/ClusteringIntegrationTests.scala b/ml/src/test/scala/frameless/ml/clustering/ClusteringIntegrationTests.scala deleted file mode 100644 index 545285473..000000000 --- a/ml/src/test/scala/frameless/ml/clustering/ClusteringIntegrationTests.scala +++ /dev/null @@ -1,73 +0,0 @@ -package frameless -package ml -package clustering - -import frameless.ml.FramelessMlSuite -import frameless.ml.classification.{TypedBisectingKMeans, TypedKMeans} -import org.apache.spark.ml.linalg.Vector -import frameless._ -import frameless.ml._ -import frameless.ml.feature._ -import org.scalatest.matchers.must.Matchers - -class ClusteringIntegrationTests extends FramelessMlSuite with Matchers { - - test("predict field2 from field1 using a K-means clustering") { - // Training - val trainingDataDs = TypedDataset.create(Seq.fill(5)(X2(10D, 0)) :+ X2(100D,0)) - - val vectorAssembler = TypedVectorAssembler[X1[Double]] - - val dataWithFeatures = vectorAssembler.transform(trainingDataDs).as[X3[Double,Int,Vector]] - - case class Input(c: Vector) - val km = TypedKMeans[Input].setK(2) - - val model = km.fit(dataWithFeatures).run() - - // Prediction - val testSeq = Seq( - X2(10D, 0), - X2(100D, 1) - ) - - val testData = TypedDataset.create(testSeq) - val testDataWithFeatures = vectorAssembler.transform(testData).as[X3[Double,Int,Vector]] - - val predictionDs = model.transform(testDataWithFeatures).as[X4[Double,Int,Vector,Int]] - - val prediction = predictionDs.select(predictionDs.col[Int]('d)).collect.run().toList - - prediction mustEqual testSeq.map(_.b) - } - - test("predict field2 from field1 using a bisecting K-means clustering") { - // Training - val trainingDataDs = TypedDataset.create(Seq.fill(5)(X2(10D, 0)) :+ X2(100D,0)) - - val vectorAssembler = TypedVectorAssembler[X1[Double]] - - val dataWithFeatures = vectorAssembler.transform(trainingDataDs).as[X3[Double, Int, Vector]] - - case class Inputs(c: Vector) - val bkm = TypedBisectingKMeans[Inputs]().setK(2) - - val model = bkm.fit(dataWithFeatures).run() - - // Prediction - val testSeq = Seq( - X2(10D, 0), - X2(100D, 1) - ) - - val testData = TypedDataset.create(testSeq) - val testDataWithFeatures = vectorAssembler.transform(testData).as[X3[Double, Int, Vector]] - - val predictionDs = model.transform(testDataWithFeatures).as[X4[Double,Int,Vector,Int]] - - val prediction = predictionDs.select(predictionDs.col[Int]('d)).collect.run().toList - - prediction mustEqual testSeq.map(_.b) - } - -} diff --git a/ml/src/test/scala/frameless/ml/clustering/KMeansTests.scala b/ml/src/test/scala/frameless/ml/clustering/KMeansTests.scala deleted file mode 100644 index 1e17087dd..000000000 --- a/ml/src/test/scala/frameless/ml/clustering/KMeansTests.scala +++ /dev/null @@ -1,71 +0,0 @@ -package frameless -package ml -package clustering - -import frameless.ml.classification.TypedKMeans -import frameless.{TypedDataset, TypedEncoder, X1, X2, X3} -import org.apache.spark.ml.linalg._ -import org.scalacheck.{Arbitrary, Gen} -import org.scalacheck.Prop._ -import frameless.ml._ -import frameless.ml.params.kmeans.KMeansInitMode -import org.scalatest.matchers.must.Matchers - -class KMeansTests extends FramelessMlSuite with Matchers { - implicit val arbVector: Arbitrary[Vector] = - Arbitrary(Generators.arbVector.arbitrary) - implicit val arbKMeansInitMode: Arbitrary[KMeansInitMode] = - Arbitrary{ - Gen.oneOf( - Gen.const(KMeansInitMode.KMeansPlusPlus), - Gen.const(KMeansInitMode.Random) - ) - } - - test("fit() returns a correct TypedTransformer") { - val prop = forAll { x1: X1[Vector] => - val km = TypedKMeans[X1[Vector]] - val ds = TypedDataset.create(Seq(x1)) - val model = km.fit(ds).run() - val pDs = model.transform(ds).as[X2[Vector, Int]] - - pDs.select(pDs.col('a)).collect().run().toList == Seq(x1.a) - } - - def prop3[A: TypedEncoder : Arbitrary] = forAll { x2: X2[Vector, A] => - val km = TypedKMeans[X1[Vector]] - val ds = TypedDataset.create(Seq(x2)) - val model = km.fit(ds).run() - val pDs = model.transform(ds).as[X3[Vector, A, Int]] - - pDs.select(pDs.col('a), pDs.col('b)).collect.run() == Seq((x2.a, x2.b)) - } - - check(prop) - check(prop3[Double]) - } - - test("param setting is retained") { - val prop = forAll { initMode: KMeansInitMode => - val rf = TypedKMeans[X1[Vector]] - .setInitMode(KMeansInitMode.Random) - .setInitSteps(2) - .setK(10) - .setMaxIter(15) - .setSeed(123223L) - .setTol(12D) - - val ds = TypedDataset.create(Seq(X2(Vectors.dense(Array(0D)), 0))) - val model = rf.fit(ds).run() - - model.transformer.getInitMode == KMeansInitMode.Random.sparkValue && - model.transformer.getInitSteps == 2 && - model.transformer.getK == 10 && - model.transformer.getMaxIter == 15 && - model.transformer.getSeed == 123223L && - model.transformer.getTol == 12D - } - - check(prop) - } -} diff --git a/ml/src/test/scala/frameless/ml/feature/TypedIndexToStringTests.scala b/ml/src/test/scala/frameless/ml/feature/TypedIndexToStringTests.scala deleted file mode 100644 index 9e2bcbcf8..000000000 --- a/ml/src/test/scala/frameless/ml/feature/TypedIndexToStringTests.scala +++ /dev/null @@ -1,34 +0,0 @@ -package frameless -package ml -package feature - -import org.scalacheck.{Arbitrary, Gen} -import org.scalacheck.Prop._ -import shapeless.test.illTyped -import org.scalatest.matchers.must.Matchers - -class TypedIndexToStringTests extends FramelessMlSuite with Matchers { - - test(".transform() correctly transform an input dataset") { - implicit val arbDouble = Arbitrary(Gen.choose(0, 99).map(_.toDouble)) - - def prop[A: TypedEncoder: Arbitrary] = forAll { x2: X2[Double, A] => - val transformer = TypedIndexToString[X1[Double]](Array.fill(100)("foo")) - val ds = TypedDataset.create(Seq(x2)) - val ds2 = transformer.transform(ds) - - ds2.collect.run() == Seq((x2.a, x2.b, "foo")) - } - - check(prop[Double]) - check(prop[String]) - } - - test("create() compiles only with correct inputs") { - illTyped("TypedIndexToString.create[String](Array(\"foo\"))") - illTyped("TypedIndexToString.create[X1[String]](Array(\"foo\"))") - illTyped("TypedIndexToString.create[X1[Long]](Array(\"foo\"))") - illTyped("TypedIndexToString.create[X2[String, Int]](Array(\"foo\"))") - } - -} diff --git a/ml/src/test/scala/frameless/ml/feature/TypedStringIndexerTests.scala b/ml/src/test/scala/frameless/ml/feature/TypedStringIndexerTests.scala deleted file mode 100644 index 37ee7857e..000000000 --- a/ml/src/test/scala/frameless/ml/feature/TypedStringIndexerTests.scala +++ /dev/null @@ -1,50 +0,0 @@ -package frameless -package ml -package feature - -import frameless.ml.feature.TypedStringIndexer.HandleInvalid -import org.scalacheck.{Arbitrary, Gen} -import org.scalacheck.Prop._ -import shapeless.test.illTyped -import org.scalatest.matchers.must.Matchers - -class TypedStringIndexerTests extends FramelessMlSuite with Matchers { - - test(".fit() returns a correct TypedTransformer") { - def prop[A: TypedEncoder : Arbitrary] = forAll { x2: X2[String, A] => - val indexer = TypedStringIndexer[X1[String]] - val ds = TypedDataset.create(Seq(x2)) - val model = indexer.fit(ds).run() - val resultDs = model.transform(ds).as[X3[String, A, Double]] - - resultDs.collect.run() == Seq(X3(x2.a, x2.b, 0D)) - } - - check(prop[Double]) - check(prop[String]) - } - - test("param setting is retained") { - implicit val arbHandleInvalid: Arbitrary[HandleInvalid] = Arbitrary { - Gen.oneOf(HandleInvalid.Keep, HandleInvalid.Error, HandleInvalid.Skip) - } - - val prop = forAll { handleInvalid: HandleInvalid => - val indexer = TypedStringIndexer[X1[String]] - .setHandleInvalid(handleInvalid) - val ds = TypedDataset.create(Seq(X1("foo"))) - val model = indexer.fit(ds).run() - - model.transformer.getHandleInvalid == handleInvalid.sparkValue - } - - check(prop) - } - - test("create() compiles only with correct inputs") { - illTyped("TypedStringIndexer.create[Double]()") - illTyped("TypedStringIndexer.create[X1[Double]]()") - illTyped("TypedStringIndexer.create[X2[String, Long]]()") - } - -} diff --git a/ml/src/test/scala/frameless/ml/feature/TypedVectorAssemblerTests.scala b/ml/src/test/scala/frameless/ml/feature/TypedVectorAssemblerTests.scala deleted file mode 100644 index 75f926ee8..000000000 --- a/ml/src/test/scala/frameless/ml/feature/TypedVectorAssemblerTests.scala +++ /dev/null @@ -1,44 +0,0 @@ -package frameless -package ml -package feature - -import org.scalacheck.Arbitrary -import org.scalacheck.Prop._ -import org.apache.spark.ml.linalg._ -import shapeless.test.illTyped - -class TypedVectorAssemblerTests extends FramelessMlSuite { - - test(".transform() returns a correct TypedTransformer") { - def prop[A: TypedEncoder: Arbitrary] = forAll { x5: X5[Int, Long, Double, Boolean, A] => - val assembler = TypedVectorAssembler[X4[Int, Long, Double, Boolean]] - val ds = TypedDataset.create(Seq(x5)) - val ds2 = assembler.transform(ds).as[X6[Int, Long, Double, Boolean, A, Vector]] - - ds2.collect.run() == - Seq(X6(x5.a, x5.b, x5.c, x5.d, x5.e, Vectors.dense(x5.a.toDouble, x5.b.toDouble, x5.c, if (x5.d) 1D else 0D))) - } - - def prop2[A: TypedEncoder: Arbitrary] = forAll { x5: X5[Boolean, BigDecimal, Byte, Short, A] => - val assembler = TypedVectorAssembler[X4[Boolean, BigDecimal, Byte, Short]] - val ds = TypedDataset.create(Seq(x5)) - val ds2 = assembler.transform(ds).as[X6[Boolean, BigDecimal, Byte, Short, A, Vector]] - - ds2.collect.run() == - Seq(X6(x5.a, x5.b, x5.c, x5.d, x5.e, Vectors.dense(if (x5.a) 1D else 0D, x5.b.toDouble, x5.c.toDouble, x5.d.toDouble))) - } - - check(prop[String]) - check(prop[Double]) - check(prop2[Long]) - check(prop2[Boolean]) - } - - test("create() compiles only with correct inputs") { - illTyped("TypedVectorAssembler.create[Double]()") - illTyped("TypedVectorAssembler.create[X1[String]]()") - illTyped("TypedVectorAssembler.create[X2[String, Double]]()") - illTyped("TypedVectorAssembler.create[X3[Int, String, Double]]()") - } - -} diff --git a/ml/src/test/scala/frameless/ml/regression/RegressionIntegrationTests.scala b/ml/src/test/scala/frameless/ml/regression/RegressionIntegrationTests.scala deleted file mode 100644 index ea964cc0c..000000000 --- a/ml/src/test/scala/frameless/ml/regression/RegressionIntegrationTests.scala +++ /dev/null @@ -1,44 +0,0 @@ -package frameless -package ml -package regression - -import frameless.ml.feature.TypedVectorAssembler -import org.apache.spark.ml.linalg.Vector -import org.scalatest.matchers.must.Matchers - -class RegressionIntegrationTests extends FramelessMlSuite with Matchers { - - test("predict field3 from field1 and field2 using a RandomForestRegressor") { - case class Data(field1: Double, field2: Int, field3: Double) - - // Training - - val trainingDataDs = TypedDataset.create(Seq.fill(10)(Data(0D, 10, 0D))) - - case class Features(field1: Double, field2: Int) - val vectorAssembler = TypedVectorAssembler[Features] - - case class DataWithFeatures(field1: Double, field2: Int, field3: Double, features: Vector) - val dataWithFeatures = vectorAssembler.transform(trainingDataDs).as[DataWithFeatures] - - case class RFInputs(field3: Double, features: Vector) - val rf = TypedRandomForestRegressor[RFInputs] - - val model = rf.fit(dataWithFeatures).run() - - // Prediction - - val testData = TypedDataset.create(Seq( - Data(0D, 10, 0D) - )) - val testDataWithFeatures = vectorAssembler.transform(testData).as[DataWithFeatures] - - case class PredictionResult(field1: Double, field2: Int, field3: Double, features: Vector, predictedField3: Double) - val predictionDs = model.transform(testDataWithFeatures).as[PredictionResult] - - val prediction = predictionDs.select(predictionDs.col('predictedField3)).collect.run().toList - - prediction mustEqual List(0D) - } - -} diff --git a/ml/src/test/scala/frameless/ml/regression/TypedLinearRegressionTests.scala b/ml/src/test/scala/frameless/ml/regression/TypedLinearRegressionTests.scala deleted file mode 100644 index bda716b46..000000000 --- a/ml/src/test/scala/frameless/ml/regression/TypedLinearRegressionTests.scala +++ /dev/null @@ -1,126 +0,0 @@ -package frameless -package ml -package regression - -import frameless.ml.params.linears.{LossStrategy, Solver} -import org.apache.spark.ml.linalg._ -import org.scalacheck.Arbitrary -import org.scalacheck.Prop._ -import org.scalatest.matchers.should.Matchers -import shapeless.test.illTyped - -class TypedLinearRegressionTests extends FramelessMlSuite with Matchers { - - implicit val arbVectorNonEmpty: Arbitrary[Vector] = Arbitrary(Generators.arbVector.arbitrary) - - test("fit() returns a correct TypedTransformer") { - val prop = forAll { x2: X2[Double, Vector] => - val lr = TypedLinearRegression[X2[Double, Vector]] - val ds = TypedDataset.create(Seq(x2)) - - val model = lr.fit(ds).run() - val pDs = model.transform(ds).as[X3[Double, Vector, Double]] - - pDs.select(pDs.col('a), pDs.col('b)).collect.run() == Seq(x2.a -> x2.b) - } - val prop2 = forAll { x2: X2[Vector, Double] => - val lr = TypedLinearRegression[X2[Vector, Double]] - val ds = TypedDataset.create(Seq(x2)) - val model = lr.fit(ds).run() - val pDs = model.transform(ds).as[X3[Vector, Double, Double]] - - pDs.select(pDs.col('a), pDs.col('b)).collect.run() == Seq(x2.a -> x2.b) - } - - def prop3[A: TypedEncoder: Arbitrary] = forAll { x3: X3[Vector, Double, A] => - val lr = TypedLinearRegression[X2[Vector, Double]] - val ds = TypedDataset.create(Seq(x3)) - val model = lr.fit(ds).run() - val pDs = model.transform(ds).as[X4[Vector, Double, A, Double]] - - pDs.select(pDs.col('a), pDs.col('b), pDs.col('c)).collect.run() == Seq((x3.a, x3.b, x3.c)) - } - - check(prop) - check(prop2) - check(prop3[String]) - check(prop3[Double]) - } - - test("param setting is retained") { - import Generators.{arbLossStrategy, arbSolver} - - val prop = forAll { (lossStrategy: LossStrategy, solver: Solver) => - val lr = TypedLinearRegression[X2[Double, Vector]] - .setAggregationDepth(10) - .setEpsilon(4) - .setFitIntercept(true) - .setLoss(lossStrategy) - .setMaxIter(23) - .setRegParam(1.2) - .setStandardization(true) - .setTol(2.3) - .setSolver(solver) - - val ds = TypedDataset.create(Seq(X2(0D, Vectors.dense(0D)))) - val model = lr.fit(ds).run() - - model.transformer.getAggregationDepth == 10 && - model.transformer.getEpsilon == 4.0 && - model.transformer.getLoss == lossStrategy.sparkValue && - model.transformer.getMaxIter == 23 && - model.transformer.getRegParam == 1.2 && - model.transformer.getTol == 2.3 && - model.transformer.getSolver == solver.sparkValue - } - - check(prop) - } - - test("create() compiles only with correct inputs") { - illTyped("TypedLinearRegressor.create[Double]()") - illTyped("TypedLinearRegressor.create[X1[Double]]()") - illTyped("TypedLinearRegressor.create[X2[Double, Double]]()") - illTyped("TypedLinearRegressor.create[X3[Vector, Double, Int]]()") - illTyped("TypedLinearRegressor.create[X2[Vector, String]]()") - } - - test("TypedLinearRegressor should fit straight line ") { - case class Point(features: Vector, labels: Double) - - val ds = Seq( - X2(new DenseVector(Array(1.0)): Vector, 1.0), - X2(new DenseVector(Array(2.0)): Vector, 2.0), - X2(new DenseVector(Array(3.0)): Vector, 3.0), - X2(new DenseVector(Array(4.0)): Vector, 4.0), - X2(new DenseVector(Array(5.0)): Vector, 5.0), - X2(new DenseVector(Array(6.0)): Vector, 6.0) - ) - - val ds2 = Seq( - X3(new DenseVector(Array(1.0)): Vector,2F, 1.0), - X3(new DenseVector(Array(2.0)): Vector,2F, 2.0), - X3(new DenseVector(Array(3.0)): Vector,2F, 3.0), - X3(new DenseVector(Array(4.0)): Vector,2F, 4.0), - X3(new DenseVector(Array(5.0)): Vector,2F, 5.0), - X3(new DenseVector(Array(6.0)): Vector,2F, 6.0) - ) - - val tds = TypedDataset.create(ds) - - val lr = TypedLinearRegression[X2[Vector, Double]] - .setMaxIter(10) - - val model = lr.fit(tds).run() - - val tds2 = TypedDataset.create(ds2) - - val lr2 = TypedLinearRegression[X3[Vector, Float, Double]] - .setMaxIter(10) - - val model2 = lr2.fit(tds2).run() - - model.transformer.coefficients shouldEqual new DenseVector(Array(1.0)) - model2.transformer.coefficients shouldEqual new DenseVector(Array(1.0)) - } -} diff --git a/ml/src/test/scala/frameless/ml/regression/TypedRandomForestRegressorTests.scala b/ml/src/test/scala/frameless/ml/regression/TypedRandomForestRegressorTests.scala deleted file mode 100644 index 0a15d45e7..000000000 --- a/ml/src/test/scala/frameless/ml/regression/TypedRandomForestRegressorTests.scala +++ /dev/null @@ -1,87 +0,0 @@ -package frameless -package ml -package regression - -import frameless.ml.params.trees.FeatureSubsetStrategy -import shapeless.test.illTyped -import org.apache.spark.ml.linalg._ -import org.scalacheck.Arbitrary -import org.scalacheck.Prop._ -import org.scalatest.matchers.must.Matchers - -class TypedRandomForestRegressorTests extends FramelessMlSuite with Matchers { - implicit val arbVectorNonEmpty: Arbitrary[Vector] = - Arbitrary(Generators.arbVector.arbitrary suchThat (_.size > 0)) // vector must not be empty for RandomForestRegressor - import Generators.arbTreesFeaturesSubsetStrategy - - test("fit() returns a correct TypedTransformer") { - val prop = forAll { x2: X2[Double, Vector] => - val rf = TypedRandomForestRegressor[X2[Double, Vector]] - val ds = TypedDataset.create(Seq(x2)) - val model = rf.fit(ds).run() - val pDs = model.transform(ds).as[X3[Double, Vector, Double]] - - pDs.select(pDs.col('a), pDs.col('b)).collect.run() == Seq(x2.a -> x2.b) - } - - val prop2 = forAll { x2: X2[Vector, Double] => - val rf = TypedRandomForestRegressor[X2[Vector, Double]] - val ds = TypedDataset.create(Seq(x2)) - val model = rf.fit(ds).run() - val pDs = model.transform(ds).as[X3[Vector, Double, Double]] - - pDs.select(pDs.col('a), pDs.col('b)).collect.run() == Seq(x2.a -> x2.b) - } - - def prop3[A: TypedEncoder: Arbitrary] = forAll { x3: X3[Vector, Double, A] => - val rf = TypedRandomForestRegressor[X2[Vector, Double]] - val ds = TypedDataset.create(Seq(x3)) - val model = rf.fit(ds).run() - val pDs = model.transform(ds).as[X4[Vector, Double, A, Double]] - - pDs.select(pDs.col('a), pDs.col('b), pDs.col('c)).collect.run() == Seq((x3.a, x3.b, x3.c)) - } - - check(prop) - check(prop2) - check(prop3[String]) - check(prop3[Double]) - } - - test("param setting is retained") { - val prop = forAll { featureSubsetStrategy: FeatureSubsetStrategy => - val rf = TypedRandomForestRegressor[X2[Double, Vector]] - .setNumTrees(10) - .setMaxBins(100) - .setFeatureSubsetStrategy(featureSubsetStrategy) - .setMaxDepth(10) - .setMaxMemoryInMB(100) - .setMinInfoGain(0.1D) - .setMinInstancesPerNode(2) - .setSubsamplingRate(0.9D) - - val ds = TypedDataset.create(Seq(X2(0D, Vectors.dense(0D)))) - val model = rf.fit(ds).run() - - model.transformer.getNumTrees == 10 && - model.transformer.getMaxBins == 100 && - model.transformer.getFeatureSubsetStrategy == featureSubsetStrategy.sparkValue && - model.transformer.getMaxDepth == 10 && - model.transformer.getMaxMemoryInMB == 100 && - model.transformer.getMinInfoGain == 0.1D && - model.transformer.getMinInstancesPerNode == 2 && - model.transformer.getSubsamplingRate == 0.9D - } - - check(prop) - } - - test("create() compiles only with correct inputs") { - illTyped("TypedRandomForestRegressor.create[Double]()") - illTyped("TypedRandomForestRegressor.create[X1[Double]]()") - illTyped("TypedRandomForestRegressor.create[X2[Double, Double]]()") - illTyped("TypedRandomForestRegressor.create[X3[Vector, Double, Int]]()") - illTyped("TypedRandomForestRegressor.create[X2[Vector, String]]()") - } - -} diff --git a/project/build.properties b/project/build.properties deleted file mode 100644 index d91c272d4..000000000 --- a/project/build.properties +++ /dev/null @@ -1 +0,0 @@ -sbt.version=1.4.6 diff --git a/project/plugins.sbt b/project/plugins.sbt deleted file mode 100644 index a6508cce4..000000000 --- a/project/plugins.sbt +++ /dev/null @@ -1,5 +0,0 @@ -addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "3.9.5") -addSbtPlugin("com.jsuereth" % "sbt-pgp" % "2.1.1") -addSbtPlugin("org.scoverage" % "sbt-scoverage" % "1.6.1") -addSbtPlugin("org.tpolecat" % "tut-plugin" % "0.6.13") -addSbtPlugin("com.codecommit" % "sbt-github-actions" % "0.9.5") \ No newline at end of file diff --git a/scripts/docs-build.sh b/scripts/docs-build.sh deleted file mode 100644 index 2d96c5f8b..000000000 --- a/scripts/docs-build.sh +++ /dev/null @@ -1,18 +0,0 @@ -#!/bin/bash - -set -eux - -sbt copyReadme tut - -gitbook="node_modules/gitbook-cli/bin/gitbook.js" - -if ! test -e $gitbook; then - npm install gitbook - npm install gitbook-cli -fi - -$gitbook build docs/target/tut docs/book - -mv docs/book/* . - -exit 0 diff --git a/scripts/docs-publish.sh b/scripts/docs-publish.sh deleted file mode 100644 index 013383ed8..000000000 --- a/scripts/docs-publish.sh +++ /dev/null @@ -1,25 +0,0 @@ -#!/bin/bash - -set -eux - -# Check that the working directory is a git repository and the repository has no outstanding changes. -git diff-index --quiet HEAD - -commit=$(git show -s --format=%h) - -git checkout gh-pages - -git merge "$commit" - -bash scripts/docs-build.sh - -git add . - -git commit -am "Rebuild documentation ($commit)" - -echo "Verify that you didn't break anything:" -echo " $ python -m SimpleHTTPServer 8000" -echo " $ xdg-open http://localhost:8000/" -echo "" -echo "Then push to the gh-pages branch:" -echo " $ git push gh-pages" diff --git a/scripts/travis-publish.sh b/scripts/travis-publish.sh deleted file mode 100755 index de97df242..000000000 --- a/scripts/travis-publish.sh +++ /dev/null @@ -1,27 +0,0 @@ -#!/bin/bash - -# Taken + modified from typelevel/cats -# https://github.com/typelevel/cats/blob/a8a7587f558541cbabc5c40053181928b4baf78c/scripts/travis-publish.sh - -export publish_cmd="publishLocal" - -# if [[ $TRAVIS_PULL_REQUEST == "false" && $TRAVIS_BRANCH == "master" && $(cat version.sbt) =~ "-SNAPSHOT" ]]; then -# export publish_cmd="common/publish cats/publish dataset/publish dataframe/publish" -# fi - -sbt_cmd="sbt ++$TRAVIS_SCALA_VERSION -Dfile.encoding=UTF8 -J-XX:ReservedCodeCacheSize=256M" - -case "$PHASE" in - A) - docs_cmd="$sbt_cmd doc tut" - run_cmd="$docs_cmd" - ;; - B) - coverage="$sbt_cmd coverage test && sbt coverageReport && bash <(curl -s https://codecov.io/bash)" - run_cmd="$coverage" - ;; - C) - run_cmd="$sbt_cmd clean $publish_cmd" - ;; -esac -eval $run_cmd diff --git a/search_index.json b/search_index.json deleted file mode 100644 index 9b2fc3bef..000000000 --- a/search_index.json +++ /dev/null @@ -1 +0,0 @@ -{"index":{"version":"0.5.12","fields":[{"name":"title","boost":10},{"name":"keywords","boost":15},{"name":"body","boost":1}],"ref":"url","documentStore":{"store":{"./":["\"0.9.0\"","\"_1\".","\"frameless","\"org.typelevel\"","\"value\"","%","%%","(e.g.","(e.g.,","(includ","(peopl","(thumb",")","++=","+1,","//","0","0.13.13:","0.4","0.4.0","0.4.1","0.5.2","0.5.x","0.6.1","0.6.x","0.7.0","0.8","0.8.0","0.9","0.9.0","0.9.x","1.0.0","1.x","2.0","2.0,","2.11","2.11/2.12","2.12","2.12.x.","2.2.0","2.2.1","2.3.0","2.3.0.","2.3.1","2.3.2.","2.4.0","20","3","3.0.0","=",">=","access","add","adelbertc","adjust","aforement","against","allow","apach","api","api,","api.","appli","applic","approach,","are:","arithmet","associ","avail","avoid","base","benefit","bootstrap","break","bring","build.sbt","built","call","cast","cat","cats\"","cats.","chang","channel","choos","click","code","collect","column","column,","columns)","compar","comparison","compat","compil","compile)","concept:","conduct","consist","consol","contain","contribut","contributor","creat","current","custom","customizable,","dataframe'","dataset","dataset\"","dataset,","dataset/datafram","default","depend","detail","develop","document","easi","effect","effect,","encod","encoder,","enhanc","environ","error","error)","essenti","exist","express","expressionencod","featur","features.","feel","few","file","file.","first","follow","follows:","frameless","frameless_gen_min_s","frameless_gen_size_rang","framelessvers","framelessversion,","free","friendli","function","g8","gener","get","giter8","github,","gitter","gitter)","ground,","help?","here","http://opensource.org/licenses/apach","ident","imario","imarios/frameless.g8","injection:","insid","instal","intention","introduc","introduct","issues/questions.","jar.","job[a]","kanterov","learning.","librari","librarydepend","licens","list(","load","made","maintain","merg","messag","minim","ml","ml\"","modul","modules:","more","need","needed:","new","next","non","note","now","numer","offici","olivierblanvillain","on","oper","outofmemoryerrors,","overhead","overview","possibl","prefer","probabl","project","project:","proof","properti","provid","pull","quick","rdd","rdds,","referenc","release,","requests)","requests.","requir","runtim","safe","same","sbt","scala","schema","second","set","sever","shapeless","shell","sign","signatur","similar)","simpli","simply:","singl","size","sizes.","spark","spark'","spark).","spark.","standard","start","still","strongli","suite:","support","tabl","test","tests.","therefore,","tune","type","typeddatafram","typeddataset","typeddataset.","typeddataset:","typelevel","types.","typesaf","under","up","up,","us","val","valu","variabl","veri","version","versions.","want","way","well","well.","why?","with,","work"],"FeatureOverview.html":["\"a","\"abc\")","\"false\")","\"lyon\",","\"paris\")","\"paris\",","$\"*\".","'`citi`'","'city),","'name),","'null'","'population)","'price),","'project","(apttypedds)","(apttypedds2)","(column:","(e.g.,","(enjoy","(frameless.typedcolumn[(string,","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(from","(i.e.,","(if","(in","(int)","(lyon,166500.0))","(name:","(or","(paris,333333.3333333333),","(short","(string,","(such","(u:","(up","(which","(with",")",").as[apartmentdetails]",").as[aptpricecity].show().run",").as[stats].show().run()",").show().run()",").show(1).run()",").show(2).run()","*","+","...","...).",".ac",".dataset",".desc.",".flattenopt",".select($\"*\",","/","//","0.0|","0.0|325000.0|","0.2,","1","1),","1.1|","10","10),","10,","100,","10000.0,","102|","133000...|","133000.0,","133000.0|","1|","1|250000.0|","2","2)","2)).","2)).show().run()","2),","2).as[updatedsurface]","2).show().run()","2).show(2).run()","2.0","200000...|","200000.0,","200000.0|","2229621),","2229621|","2229621}|","2409.6385542168673,","25,","25000...|{paris,","250000.0,","250000.0|","250|","25|[paris,","27|","2955.5555555555557,","2:","2|","2|300000.0|","2|[a,","2}|[a,","3","3)","3),","30000...|{paris,","300000.0,","300000.0|","325000...|","325000.0,","325000.0|","343629)","343629|","343629}|","3|","3|450000.0|","3|[a,","4","42","4391.891891891892)","4391.891891891892|","45,","4500...|{paris,","4500.0,","450000.0,","450000.0|","450|","45|133000.0|","47|","4|","50,","500715),","500715|","500715}|","500|","50|300000.0|","52|","6833.333333333333|","74,","740|","76|","83,","830|","83|200000.0|","85|","9000.0|",":",":26:",":27:",":28:",":29:",":35:",":36:","=","==","===","=>","['citi]","[1...10]).","[_1:","[bedrooms,","[city#1384,","[city:","[out,","[ratio:","[tt,","[value:","^","_1.","_1|","_2:","_2|","_3|","_4|","a)(implicit","a,","ab","abov","access","accident","action","actual","ad","adapt","add","added,","addit","addition,","address","adjustedpric","adjustedprice.show().run()","adjustedprice:","advanc","again","agg()","agg(avg(aptds('price))).","aggreg","aggregated,","agree.","align","align.","allcities:","allcities|","allow","allowed,","allowed:","alternatives:","and/or","anoth","anyth","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartment.","apartmentdetail","apartmentdetails(city:","apartmentdetails?","apartmentopt(city:","apartmentopt(none,","apartmentopt(some(\"paris\"),","apartmentshortinfo","apartmentshortinfo(city:","apartmentshortinfo?","apartmentsopt","api","api,","api.","apis),","appear","appli","aptd","aptds('city),","aptds('price)","aptds('price)))","aptds('price),","aptds('surface),","aptds('surface).cast[double]","aptds('surface).cast[double])","aptds.","aptds.agg(","aptds.select(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)","apttypedds('city)).as[updatedsurface]","apttypedds('city).asc,","apttypedds('city).cast[double]","apttypedds('price).desc","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.joininner(citiinfotypedds)","apttypedds.makeudf(pricemodifier)","apttypedds.orderby(","apttypedds.orderby(apttypedds('city).asc).show(2).run()","apttypedds.project[apartmentshortinfo]","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds.union(apttypedds2).show().run","apttypedds2","apttypedds2('price)","apttypedds2('price)).","apttypedds2.drop[citybeds]","apttypedds2.droptupled('price):","apttypedds2.union(apttypedds).show().run","apttypedds2.withcolumnreplaced('price,","apttypedds2.withcolumntupled(","apttypedds2.withcolumntupled(lit(array(\"a\",\"b\",\"c\"))).show(2).run()","apttypedds2:","apttypedds:","apttypeddsopt","apttypeddsopt('surface)","apttypeddsopt('surface).opt.map(_","apttypeddsopt.select(apttypeddsopt('surface)","apttypeddsopt.select(apttypeddsopt('surface).opt.map(c","apttypeddsopt.show().run()","apttypeddsopt:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","argument","arguments)","around","array]","arraycontains(t('_1),","arraycontains(t('_2),","arraycontains:","as:","as[bedroomstats]","as[t]","ascol","ascol()","assum","automat","avail","available.","averag","avg","avg(aptds('price))","avg(aptds('price)),","avg(aptds('surface))","avg(aptds('surface)),","avgprice:","avgpricebeds1:","avgpricebeds2:","avgpricebeds3:","avgpricebeds4:","avgprice|","avgsurface:","avgsurface|minsurface|","b,","base","becom","bedroom","bedrooms#1387]","bedrooms.","bedrooms:","bedroomstat","bedroomstats(","bedroomstats('avgpricebeds2).getorelse(0.0),","bedroomstats('avgpricebeds3).getorelse(0.0))","bedroomstats(lyon,some(133000.0),some(200000.0),none,none)","bedroomstats(nice,none,none,some(325000.0),none)","bedroomstats(paris,some(250000.0),some(300000.0),some(450000.0),none)","bedroomstats.collect().run().foreach(println)","bedroomstats.dataset.todf().filter($\"avgpricebeds2\".isnotnull)","bedroomstats.flattenoption('avgpricebeds2)","bedroomstats.select(","bedroomstats.show().run()","bedroomstats:","behavior","bellow:","below.","best","better","between","boolean","boolean)].","bypass","c","c('_2)).show(2).run()","c,","c.","c.select(c.colmany('_1,","c.show(1).run()","c:","c]|","calcul","call","caller","can't","care","case","case,","cases.","cast","cast,","catalystcast.","catalystcast[string,","chang","change.","check","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name)","city,","city:","cityb","citybeds(city:","citybeds(lyon,2))","citybeds(paris,1))","citybeds(paris,1),","citybeds(paris,3))","citybeds(paris,3),","citybeds.","citybeds.head(3).run()","citybeds.headoption.run()","citybeds.limit(4).collect().run()","citybeds.select(citybeds.ascol,","citybeds.take(2).run()","citybeds:","citybedsoth","citybedsother(city:","cityinfo","cityinfo(city:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.select(cityratio('city),","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|avgpricebeds1|avgpricebeds2|avgpricebeds3|avgpricebeds4|","city|bedrooms|","city|surface|","class","class:","claus","clause.","code","collect","collect())","collection,","collectset(aptds('city))","colmany()","column","column\")","column,","column.","column:","columns,","columns.","columns:","combin","common","compar","compat","compil","compile,","compile.","compile:","compiles:","complet","complex","comput","computations.","concat,","condition","conf","contain","context","continu","convention.","convert","correspond","count,","creat","d]|true|","data","dataframe,","dataframes,","dataset","dataset.","dataset:","deal","defin","design,","detail","directli","divid","divided,","done","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","drop","drop().","drop/replace/add","droptupled()","e.g.,","e:","each","easier","easili","element","elements.","elid","empti","encod","entir","equival","equivelantli","error","error.","error:","etc.).","evid","evidence$1:","exactli","exampl","example,","example.","except","exist","expect","explan","explicitli","explode()","explode(_2)","explode(_2),","expos","express","expression'","extra","fail","faster","featur","few","field","field]","fields.","fields]","finally,","find","first","five","flatten","flattened.show(4).run()","flattened:","flattenstat","flattenstats:","follow","form","formal","found","frameless","frameless'","frameless,","frameless.abstracttypedcolumn[?t,?c[?a]]","frameless.abstracttypedcolumn[t,c[a]]","frameless.abstracttypedcolumn[t,c[a]],","frameless.catalystcast[string,double]","frameless.catalystcollection[c])column.thistype[t,boolean]","frameless.catalystdivisible[double,out],","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.catalystnumeric[option[int]])frameless.typedcolumn[apartmentopt,option[int]]","frameless.catalystnumeric[option[int]],","frameless.functions._","frameless.functions.aggregate._","frameless.functions.lit","frameless.functions.nonaggregate._","frameless.functions.nonaggregate.when","frameless.functions.udf$$lambda$12549/0x0000000803898840@61521397","frameless.ops.as[(string,","frameless.syntax._","frameless.typedcolumn[(string,","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[tt,double])(implicit","frameless.typedcolumn[tt,option[int]])(implicit","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(citybeds,","frameless.typeddataset[(double,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[apartmentopt]","frameless.typeddataset[apartmentshortinfo]","frameless.typeddataset[bedroomstats]","frameless.typeddataset[citybeds]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[this.out]","frameless.typeddataset[updatedsurface]","frameless.typedencoder[out],","frameless.with[apartment,tt]{typ","frameless.with[apartmentopt,tt]{typ","function","functions.","further","gener","get","getorelse().","give","given","group","groupbi","groupby()","groupby(aptds('city)).","hand","harder","help","here","here.","here:","however,","id","if(nam","ignor","imperfections,","implement","implicit","import","includ","inflat","inflation.show(2).run()","inflation:","inform","initi","input","instanc","instance,","instances:","instanti","instead","instead.","int","int)","int).","int)]","int,","int.","int]","interest","introduc","issue,","issue:","it'","job","join","known","later","lazi","lazy.","let","let'","lift","list[int])]","list[string])","list[string]),string]","list[string]),string],","list[string])]","lit(0.001))","lit(1.1)).","lit(list(\"a\",\"b\",\"c\")))","lit(list(\"abc\",\"c\",\"d\")))","lit(list(1,2,3,4)))","litaggr(\"hello","liter","localrel","long","long,","look","lose","lyon]|","lyon|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","macro","main","make","mani","map()","match","materialize.","math","matter","member","method","method.","min(aptds('surface)),","min(aptds('surface)).cast[double],","minimum","minsurface:","mismatch;","miss","missing,","misspel","mistak","more","multipl","n","n:","name","name:","names/typ","names/types,","need","nest","new","next","next,","nice,","nice|","nice|325000.0|","non","none","none),","none).","none,","not,","note","now","null).","null|","null|450000.0|","number","often,","on","on(1,2,3,4).","oper","operation.","operations:","opt","option","option.","option[citybeds]","option[double]","option[double])","option[double])]","option[double],","option[int])","option[int])(implicit","option[int],","option[string],","option[x]","options.","order","order.","org.apache.spark.sql,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$$anonfun$apply$22.applyorelse(analyzer.scala:2503)","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$$anonfun$apply$22.applyorelse(analyzer.scala:2510)","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$.apply(analyzer.scala:2447)","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$.apply(analyzer.scala:2503)","org.apache.spark.sql.catalyst.analysis.analyzer.$anonfun$executeandcheck$1(analyzer.scala:173)","org.apache.spark.sql.catalyst.analysis.analyzer.$anonfun$executeandcheck$1(analyzer.scala:175)","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.analyzer.execute(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.analyzer.execute(analyzer.scala:189)","org.apache.spark.sql.catalyst.analysis.analyzer.executeandcheck(analyzer.scala:172)","org.apache.spark.sql.catalyst.analysis.analyzer.org$apache$spark$sql$catalyst$analysis$analyzer$$executesamecontext(analyzer.scala:195)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$$nestedinanonfun$checkanalysis$1$2.applyorelse(checkanalysis.scala:152)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$$nestedinanonfun$checkanalysis$1$2.applyorelse(checkanalysis.scala:155)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1$adapted(checkanalysis.scala:93)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1(checkanalysis.scala:152)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkanalysis$(checkanalysis.scala:90)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkanalysis(checkanalysis.scala:93)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.plans.logical.analysishelper$.allowinvokingtransformsinanalyzer(analysishelper.scala:221)","org.apache.spark.sql.catalyst.plans.logical.analysishelper$.markinanalyzer(analysishelper.scala:228)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.$anonfun$resolveoperatorsup$1(analysishelper.scala:90)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.$anonfun$resolveoperatorsup$3(analysishelper.scala:90)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.resolveoperatorsup$(analysishelper.scala:84)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.resolveoperatorsup(analysishelper.scala:86)","org.apache.spark.sql.catalyst.plans.logical.logicalplan.resolveoperatorsup(logicalplan.scala:29)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$1(queryplan.scala:116)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$3(queryplan.scala:132)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$4(queryplan.scala:137)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$transformexpressionsup$1(queryplan.scala:104)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:137)","org.apache.spark.sql.catalyst.plans.queryplan.recursivetransform$1(queryplan.scala:127)","org.apache.spark.sql.catalyst.plans.queryplan.recursivetransform$1(queryplan.scala:132)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:116)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:104)","org.apache.spark.sql.catalyst.queryplanningtracker$.withtracker(queryplanningtracker.scala:88)","org.apache.spark.sql.catalyst.queryplanningtracker.measurephase(queryplanningtracker.scala:111)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$execute$1$adapted(ruleexecutor.scala:205)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$execute$1(ruleexecutor.scala:213)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$execute$2(ruleexecutor.scala:216)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$executeandtrack$1(ruleexecutor.scala:183)","org.apache.spark.sql.catalyst.rules.ruleexecutor.execute(ruleexecutor.scala:205)","org.apache.spark.sql.catalyst.rules.ruleexecutor.executeandtrack(ruleexecutor.scala:183)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:73)","org.apache.spark.sql.catalyst.trees.treenode.$anonfun$transformup$2(treenode.scala:341)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:183)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:243)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:341)","org.apache.spark.sql.dataset$.$anonfun$ofrows$1(dataset.scala:90)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:88)","org.apache.spark.sql.dataset.select(dataset.scala:1462)","org.apache.spark.sql.dataset.withplan(dataset.scala:3715)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.dataset[org.apache.spark.sql.row]","org.apache.spark.sql.errors.querycompilationerrors$.morethanonegeneratorerror(querycompilationerrors.scala:95)","org.apache.spark.sql.execution.queryexecution.$anonfun$analyzed$1(queryexecution.scala:73)","org.apache.spark.sql.execution.queryexecution.$anonfun$executephase$1(queryexecution.scala:143)","org.apache.spark.sql.execution.queryexecution.analyzed$lzycompute(queryexecution.scala:73)","org.apache.spark.sql.execution.queryexecution.analyzed(queryexecution.scala:71)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:63)","org.apache.spark.sql.execution.queryexecution.executephase(queryexecution.scala:143)","org.apache.spark.sql.functions.{explod","org.apache.spark.sql.sparksess","org.apache.spark.sql.sparksession.withactive(sparksession.scala:772)","org.apache.spark.{sparkconf,","origin","other:","otherwise(lit(0.0))).show(8).run()","other|","out","overload","overview","paramet","part","particular","per","perform","perhap","pivot","pivot(aptds('bedrooms)).","pivot,","popul","population:","potenti","prefer","preserv","previou","price","price#1386,","price,","price/surfac","price:","price:double)","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.select(pricebysurfaceunit.ascol","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","price|bedrooms|","problem","project","project,","prove","provid","rais","ratio","ratio:","ratio|","readi","real","recommend","refer","referenc","reflect","remov","repl\").set(\"spark.ui.enabled\",","replac","repres","requir","required:","res18:","res20:","res30:","res31:","res32:","res33:","res38:","res45:","res46:","res4:","resolv","result","result.","retriev","return","right?","row","run()","runtim","safe","safe,","safe.","safeti","safety,","safety.","same","samplestat","samplestats.show().run()","samplestats:","scala","scala,","scala.collection.abstracttraversable.map(traversable.scala:108)","scala.collection.immutable.list.foldleft(list.scala:91)","scala.collection.immutable.list.foreach(list.scala:431)","scala.collection.linearseqoptimized.foldleft$(linearseqoptimized.scala:122)","scala.collection.linearseqoptimized.foldleft(linearseqoptimized.scala:126)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:49)","scala.collection.mutable.resizablearray.foreach$(resizablearray.scala:55)","scala.collection.mutable.resizablearray.foreach(resizablearray.scala:62)","scala.collection.traversablelike.$anonfun$map$1(traversablelike.scala:285)","scala.collection.traversablelike.map$(traversablelike.scala:278)","scala.collection.traversablelike.map(traversablelike.scala:285)","scala.reflect.classtag[option[int]])frameless.typedcolumn[w,option[int]]","scala>","scalar","scalar,","schema","schema.","second","secondari","see","seem","select","select()","select().","selectmany()","selectmany(),","seq(","seq[(string,","seq[citybeds]","seq[double]","set","shapeless.tag.tagged[string(\"citi\")]","shorter","show","show()","show(1).run()","shown","similar","similarly,","simpl","simplifi","since,","singl","skip","some(10).map(c","some(3))","some(300000.0),","some(450000.0),","some(50),","some(citybeds(paris,2))","sort","sorting.","sourc","spark","spark'","spark,","spark.","spark.createdataset(apartments)","spark.implicits._","spark.sparkcontext.setloglevel(\"warn\")","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparkexplode($\"_2\"))","sparkexplode}","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","stack","standard","start","stat","statement","stats(","string","string(\"abc\")","string)","string),updatedsurface]","string,","string.","string]","struct,","struct]","subset","such","suffer","suggests,","sum,","support","suppos","surfac","surface#1385,","surface,","surface:","surface];","symbol","syntax","syntax:","t","t.withcolumntupled(","t2","t2.dataset.todf().select(sparkexplode($\"_2\"),","t2.explode('_2):","t2:","t:","take","tell","those","three","throw","time","time,","time.","top","topic","trace):","transform","transformations.","tri","tt,","tupl","tutori","tutorial.","two","type","type)","type:","type;","typedaggreg","typedcolumn","typeddataset","typeddataset.","typeddataset.create(apartments)","typeddataset.create(apartmentsopt)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[(string,int)]","typeddataset[a]","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[apartmentshortinfo]","typeddataset[citybeds]","typeddataset[double])","typeddataset[long].","typeddataset[string]","typeddataset[t]","typeddataset[tuple1[a]].","typeddataset[tuple1[long]]","typeddataset[tuplen[...]]","typeddataset[u]","typeddatset.","types,","typesaf","typesafeti","typo","u","udf","udf()","udf().","udf(aptds('city),","udf:","underli","unfortun","union","unit:","unlik","unsaf","unwrap","up","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","usag","user","val","valid","valu","value.","value:","values.","value|","vanilla","vector[string])","verifi","w:","w](other:","want","way","way,","well.","when(apttypedds2('city)","when/otherwis","whenev","wherea","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withcolumn()","withcolumn[citybedsother](lit(list(\"a\",\"b\",\"c\"))).","withcolumntupled()","without","work","worked,","world\")","world|","wrappedarray((nice,325000.0),","wrappedarray(6000.0,","wrappedarray(citybeds(paris,2),","written","w})frameless.typedcolumn[w,option[int]]","w})frameless.typedcolumn[w,out]","w},","x.","{","{lyon,","{nice,","|","|1000|102|","|12000.0|","|200000.0|","|276333.3333333333|62.833333333333336|","|300000.0|450000.0|","|4500.0|450000.0|","|6000.0|300000.0|","|6908333.333333333|12.566666666666668|hello","|city|surface|","|lyon|","|null|null|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|paris|[a,","|paris|[abc,","|{lyon,","|{nice,","|{paris,","}"],"TypedDatasetVsSparkDataset.html":["\"e\")","\"java.util.date\",","\"jday\")","\"mydate\"","\"q\")","\"w\")","$\"i\"*2)","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","'(sum(`i`)","'`i`'","'`x`'","'project","(case","(class:","(i","(i#23l","(int,","(isnotnull(i#23l)","(look","(or","(see","(the",")","*","*(1)","+",",","...",".appli","//","10))","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10).select(fds('i)).explain()","10).select(fds('i)).show().run()","10).select(fds('x))","10)],","10|","133|","1|","2)#165l]","42",":",":20:",":24:",":25:",":26:","::","=","==","===","=>","['x]","[],","[a]frameless.typedcolumn[foo,a]","[i#23l","[i#23l,j#24]","[i#23l]","[i,","[i:","[input[0,","[isnotnull(i#23l),","[isnotnull(i),","[out]frameless.typedaggregate[foo,out]","[sum(i#23l)","^","`sum(i)`)'","above.","access","achiev","act","ad","aggreg","allow","api","appli","applications.","area","argument","as[long]","assum","averaging,","avoid","bar","bar(1)))","bar(i:","bar.","batched:","before.","between","bigint","bigint))","bigint,","bigint]","bind","both","bug","bulletproof:","captur","care","case","cast","cast(10","cast(2","catalyst","class","class:","classes)","clearli","closur","closures.","code","code.","column","columnar","columnartorow","columns,","columns:","compar","comparison,","compil","compromis","confus","content","context","correct.","correctli","creat","current","datafilters:","dataset","dataset.","dataset[long].","datasets,","defin","deserializetoobject","detail.","detect","differ","discuss","discussion.","disk","distinguish","don't","ds","ds.filter($\"i\"","ds.filter(_.i","ds.select(sum($\"i\"),","ds.show()","ds:","each","elid","empty,","encod","encoder:","encoder[bar]","entir","equalto(i,10)],","error","error.","error:","etc)","exampl","example,","exist","expect","explain","explicitli","express","extrem","e|","fail","failure:","false]","familiar","fd","fds('i)).show().run()","fds.agg(fsum(fds('i))+22).show().run()","fds.agg(fsum(fds('i)),","fds.filter(fds('i)","fds.select(fsum(fds('i)))","fds:","few","field","fields.","file","file.","filescan","filter","filteredd","filteredds.explain()","filteredds.show()","filteredds:","find","first","first()","first,","first_value)","follow","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo,","foo.","format","format:","found","frameless","frameless'","frameless,","frameless.functions.aggregate.{sum","frameless.functions.aggregate.{sum=>fsum}","frameless.syntax._","frameless.typedaggregate[foo,?]","frameless.typedcolumn[foo,?]","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[mydate]","frameless:","friend.","fsum}","fulli","function","function(s)","function.","futur","generated.","get.;","give","given","goal:","great!","group","guard","handhold","help","here","here.","hold","however,","implement","implicit","import","improv","incompat","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inmemoryfileindex[file:/tmp/foo],","input","insid","instanc","instanti","instead.","int)","introduc","intuitively,","it'","i|","j.","j:","j];","java.lang.unsupportedoperationexception:","java.util.d","java.util.date(system.currenttimemillis))))","java.util.date)","j|","know","last","lead","let'","limit","line","linux","load","location:","long","long,","look","mac","make","map","mapel","member","members.","mention","method","mistak","mix","more","mydat","mydate(jday:","name","name:","need","newinstance(class","next","nil","non","note","notifi","now,","obj#72:","obj#73:","ok","on","oper","operations,","optim","optimizer)","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer.$anonfun$executeandcheck$1(analyzer.scala:175)","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.analyzer.executeandcheck(analyzer.scala:172)","org.apache.spark.sql.catalyst.analysis.analyzer.failanalysis(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$$nestedinanonfun$checkanalysis$1$2.applyorelse(checkanalysis.scala:152)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$$nestedinanonfun$checkanalysis$1$2.applyorelse(checkanalysis.scala:155)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1$adapted(checkanalysis.scala:93)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1(checkanalysis.scala:152)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1(checkanalysis.scala:299)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$12$adapted(checkanalysis.scala:272)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$12(checkanalysis.scala:272)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$15$adapted(checkanalysis.scala:299)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$15(checkanalysis.scala:299)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkanalysis$(checkanalysis.scala:90)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkanalysis(checkanalysis.scala:93)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkvalidaggregateexpression$1(checkanalysis.scala:263)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkvalidaggregateexpression$1(checkanalysis.scala:272)","org.apache.spark.sql.catalyst.analysis.checkanalysis.failanalysis$(checkanalysis.scala:49)","org.apache.spark.sql.catalyst.analysis.checkanalysis.failanalysis(checkanalysis.scala:50)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:56)","org.apache.spark.sql.catalyst.plans.logical.analysishelper$.markinanalyzer(analysishelper.scala:228)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$1(queryplan.scala:116)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$3(queryplan.scala:132)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$4(queryplan.scala:137)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$transformexpressionsup$1(queryplan.scala:104)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:137)","org.apache.spark.sql.catalyst.plans.queryplan.recursivetransform$1(queryplan.scala:127)","org.apache.spark.sql.catalyst.plans.queryplan.recursivetransform$1(queryplan.scala:132)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:116)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:104)","org.apache.spark.sql.catalyst.queryplanningtracker.measurephase(queryplanningtracker.scala:111)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$1(scalareflection.scala:562)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$1(scalareflection.scala:591)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$6(scalareflection.scala:577)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfortype$1(scalareflection.scala:421)","org.apache.spark.sql.catalyst.scalareflection$.cleanupreflectionobjects(scalareflection.scala:49)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:432)","org.apache.spark.sql.catalyst.scalareflection$.serializerfortype(scalareflection.scala:413)","org.apache.spark.sql.catalyst.scalareflection.cleanupreflectionobjects$(scalareflection.scala:903)","org.apache.spark.sql.catalyst.scalareflection.cleanupreflectionobjects(scalareflection.scala:904)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:73)","org.apache.spark.sql.catalyst.trees.treenode.$anonfun$transformup$2(treenode.scala:341)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:183)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:243)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:341)","org.apache.spark.sql.dataset$.$anonfun$ofrows$1(dataset.scala:90)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:88)","org.apache.spark.sql.dataset.(dataset.scala:210)","org.apache.spark.sql.dataset.(dataset.scala:216)","org.apache.spark.sql.dataset.select(dataset.scala:1462)","org.apache.spark.sql.dataset.select(dataset.scala:1517)","org.apache.spark.sql.dataset.withplan(dataset.scala:3715)","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.encoders$.product(encoders.scala:285)","org.apache.spark.sql.execution.queryexecution.$anonfun$analyzed$1(queryexecution.scala:73)","org.apache.spark.sql.execution.queryexecution.$anonfun$executephase$1(queryexecution.scala:143)","org.apache.spark.sql.execution.queryexecution.analyzed$lzycompute(queryexecution.scala:73)","org.apache.spark.sql.execution.queryexecution.analyzed(queryexecution.scala:71)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:63)","org.apache.spark.sql.execution.queryexecution.executephase(queryexecution.scala:143)","org.apache.spark.sql.functions.sum","org.apache.spark.sql.lowprioritysqlimplicits.newproductencoder$(sqlimplicits.scala:251)","org.apache.spark.sql.lowprioritysqlimplicits.newproductencoder(sqlimplicits.scala:251)","org.apache.spark.sql.sparksession.withactive(sparksession.scala:772)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:32)","os","paramet","parquet","parquet,","partial","partitionfilters:","pass","performance.","physic","plan","plan,","plan.","plan:","polymorph","popular","practic","primit","problem","problem.","problemat","product","product,","project","projections/selections.","provid","pushedfilters:","queri","quick","q|","read","readschema).","readschema:","refer","relation[i#23l,j#24]","releases.","remind","requir","required:","resolv","result","return","root","run","runtim","safe","safe.","safety!","safety.","save","scala","scala.","scala.collection.immutable.list.foreach(list.scala:431)","scala.collection.immutable.list.map(list.scala:293)","scala.collection.immutable.list.map(list.scala:305)","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:49)","scala.collection.mutable.resizablearray.foreach$(resizablearray.scala:55)","scala.collection.mutable.resizablearray.foreach(resizablearray.scala:62)","scala.collection.traversablelike.$anonfun$map$1(traversablelike.scala:285)","scala.collection.traversablelike.map$(traversablelike.scala:278)","scala.collection.traversablelike.map(traversablelike.scala:285)","scala.reflect.internal.tpe.typeconstraints$undolog.undo(typeconstraints.scala:73)","scala>","schema","second,","see","select","select()","sense,","separately,","sequenc","serial","serializefromobject","serv","set","shapeless.tag.tagged[string(\"x\")]","show","similarly,","simpl","simplist","slow","small","solut","solv","spark","spark'","spark.","spark.createdataset(","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark:","sparksess","standard","start","statement","statement).","store","string)","string,","string]","struct","subset","such","suffici","suggests,","sum","sum(i)#164l,","support","symbol","syntax","syntax.","take","thing","this.","time","time.","time:","togeth","tri","true,","tutori","two","two.","type","type.","type;","typedaggreg","typedcolumn","typeddataset","typeddataset.","typeddataset.create(ds)","typeddataset.create(seq(mydate(new","unabl","unfortunately,","us","val","valu","value#158l]","value#74l]","veri","view","vs","want","way","well","window","without","work","wrap","w|","x","x:","|","|100|","|value|"],"TypedEncoder.html":["\"daterange\"","\"java.util.date\",","\"s\")","\"s\"))))","\"s\",","(a","(and","(class:","...","//","2.0)","42",":28:",":30:","=","[i:","^","annoy","approach","around","b:","bar","bar(1.1,","bar(d:","bar)","bardate(1.1,","bardate(d:","bardate)","base","be","behav","besid","call","care","case","class","class:","classes.","code","compil","construct","coupl","current","custom","data","data.","dataset","dataset?.","dataset[daterange]","daterange(s:","decod","defin","deriv","derived,","detect","different,","double,","ds.collect()","ds:","e:","elid","encod","encoder.","encoder:","encoders,","ensur","error","error:","exampl","example,","exist","expected:","extend","fail","field","find","follow","foo","foo(i:","foodate(i:","found","frameless","frameless.job$$anon$4@77bca0d3","frameless.job[seq[foo]]","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[foo]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless:","gener","goe","hierarchi","ident","implicit","implicitli","import","inabl","int,","intern","introduc","issues.","java.lang.unsupportedoperationexception:","java.util.d","java.util.date)","java.util.date)))","java.util.date))))","java.util.date)).tods()","java.util.date,","jvm","lead","limit","manipul","mechan","method","more","name:","new","non","note","object","of)","onc","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:56)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$1(scalareflection.scala:562)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$1(scalareflection.scala:591)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$6(scalareflection.scala:577)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfortype$1(scalareflection.scala:421)","org.apache.spark.sql.catalyst.scalareflection$.cleanupreflectionobjects(scalareflection.scala:49)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:432)","org.apache.spark.sql.catalyst.scalareflection$.serializerfortype(scalareflection.scala:413)","org.apache.spark.sql.catalyst.scalareflection.cleanupreflectionobjects$(scalareflection.scala:903)","org.apache.spark.sql.catalyst.scalareflection.cleanupreflectionobjects(scalareflection.scala:904)","org.apache.spark.sql.dataset","org.apache.spark.sql.encoders$.product(encoders.scala:285)","org.apache.spark.sql.lowprioritysqlimplicits.newproductencoder$(sqlimplicits.scala:251)","org.apache.spark.sql.lowprioritysqlimplicits.newproductencoder(sqlimplicits.scala:251)","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:32)","overflow","paramet","pass","performance.","prove","question","recurs","reflect","represent","res1:","resolut","root","run","runtim","runtime.","s:","same","scala.collection.immutable.list.map(list.scala:293)","scala.reflect.internal.tpe.typeconstraints$undolog.undo(typeconstraints.scala:73)","scala>","scalareflect","schema.","see","seq(daterange(new","shapeless'","shown","situat","solv","spark","spark'","spark.implicits._","spark:","stack","standard","store","string)","string,","struct]","summari","support","t:","take","through","time,","time.","time:","trace,","tri","type","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset[daterange]","typeddataset[foo]","typeddataset[foodate]","typeencod","types.","us","val","valu","vanilla","won't","work"],"Injection.html":["$anon$1@17559031","//","1","19","2","2021))","20:29:11","3",":23:",":31:",":35:","=","=>","[age:","^","a):","again","anoth","apply(a:","apply(d:","available,","b","b):","b.","b]","bigint]","birthday:","can't,","case","class","class:","compil","creat","custom","d.gettime()","datetolonginject","datetolonginjection:","def","defin","definit","encod","encoder:","error.","error:","exampl","exhaustive.","extend","fail","family:","femal","female,","find","follow","frameless._","frameless.injection$$anon$1@7c0fbe02","frameless.injection$$anon$1@7d716477","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.typeddataset[person]","frameless.typedencoder[person]","function:","gender","gender)","gender:","gendertoint:","implicit","import","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","inputs:","instanc","int,","int]","invert(b:","invert(l:","jan","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date)","java.util.date))","java.util.date).gettime(),","java.util.date):","java.util.date.","less","let","let'","list(person(42,male))","list(person(42,tu","long","long)))","long):","long:","long]","look","male","male))","male,","match","more","new","now","object","on","paramet","peopl","people:","person","person(age:","persond","personds:","precis","pst","seal","seq(person(42,","seq[person]","serializ","simpl","trait","tri","type","type,","typeclass:","typeddataset,","typeddataset.create(people)","typeddataset:","typedencod","us","val","valu","verbos","warning:","{","}","})","},"],"Job.html":["(a","(sample:","//","1","20%","20)","=","=>","[value:","abil","above)","above,","allow","along","annotate/nam","applic","be","block","calcul","call","captur","cat","cats.effect.sync","collect","compar","complex","compos","composit","comprehens","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","constructor","count","countandtakejob","data","def","default","description.","differ","driver","ds","ds:","easier","effect","effects.","element","elements:","exactli","exampl","example,","execut","expens","explicit","explicitli","f[_]","f[a]","f[a],","few","finaljob","finaljob.","finaljob:","first","frameless.","frameless.job","frameless.job$$anon$2@123416f3","frameless.job[int]","frameless.job[seq[int]])frameless.job[int]","frameless.syntax._","frameless.typeddataset[int]","functions:","further","group","have","help","id","implement","implicitli","import","inform","instanc","instance.","int","int]","issues.","job","job[a]","job[int]","job[seq[int]]):","jobs.","lazi","lazili","lazy,","lazy.","make","mention","min\").","module,","monad","more","new","non","now","obviou","open","oper","order","part","pass","perform","place","predict","program","programm","provid","repres","requir","res2:","result","return","run","run()","sample.map(_.min)","say,","see","sequenc","serv","sever","show","showcas","size","spark","spark.","sparkdelay","sparkdelay[f[_]]","sparksession.","specifi","strict","such","support","suspend","suspens","thunk","toy","track","track,","transform","type","typeclass","typeclass,","typeddataset","typeddataset.create(1","ui","us","user","val","value,","via","withdescription(\"sampl","withgroupid(\"samplingjob\").","{"],"Cats.html":["\"another\")))","\"string\"),","\"task2\"","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(0,0,0)","(1,","(1,2,3)","(10,9,9)","(2,","(8,","(8,2,3)","(and","(chris,map(0","(john,map(0","(sam,map(0","(semigroup)","(seq[(int,","(wrappedarray((1,string)),2)",")","//","1","1)","1))","1)),","1),","1,","10))","10,","100)","11))","12)","12,","15)))","2","2)","2))","2)),","2,","20)","20,","3)","3))","3,","32,","4))","4)),","4,","5,","6,",":43",":45",":46",":49","::","=",">","[_1:","_2:","abil","above.","abstract","action","action[(seq[(int,","action[t]","aggreg","algebra","alia","alias","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","anna","api","arbitrari","arity.","array((joe,map(0","array[(username,","assum","avg,","be","below","block","capabl","captur","case","cat","cats.data.readert","cats.effect.implicits._","cats.effect.io","cats.effect.sync[f].","cats.implicit","cats.implicits._","cats.mtl.implicits._","cats:","class","cmax","cmin","collect","column","combin","common","complex","comput","constructor","conveni","counterpart","csum,","data","data.","data:","dataset","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","deal","default","defin","delay","descript","differ","effect","effect:","effects.","element","empti","empty,","emptyrdd","emptyrdd[13]","enhanc","enrich","etc.","exampl","example,","example:","execut","exist","f[_]","f[_],","first","follow","frameless","frameless.cats.implicits.","frameless.cats.implicits._","frameless.cats.implicits._.","frameless.cats.outer._","frameless.syntax._","frameless.typeddataset","frameless.typeddataset[(int,","frameless:","full","general).","given","group","implicit","implicits.scala:42","implicits.scala:67","import","insid","instanc","int","int)]","int,","integr","io","job,","joe","join","kernel","key","key.","keys.","larg","layer","lazy.","leverag","library:","local","long)","long)]","machineri","main","makerdd","map(0","map(1","map(bob","map(task1","map[int,int]","mappartitionsrdd[23]","mapvalu","max,","meaning","method","min,","modifi","module,","monad","more","mtl","namely,","need","nil","nil)","none","normal","note","noth","now,","offer","on","oper","option","order","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","outer","over","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","pair","parallelcollectionrdd[12]","parallelcollectionrdd[14]","parallelcollectionrdd[16]","parallelcollectionrdd[18]","parallelcollectionrdd[19]","part","plain","pre","predicates.","previous","println(data.cmax)","println(data.cmaxoption)","println(data.cmin)","println(data.cminoption)","println(data.csum)","println(data.csumoption)","program,","properli","provid","r","rdd","rdd.","rdd:","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","readert","readert[io,","reducebykey","repres","request","res16:","res17:","res19:","res20:","res5:","result","result.run(spark).unsaferunsync()","result:","resultwithdescription:","return","run","run:","same","sampl","sc.emptyrdd","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala.collection.immutable.map[int,int]","scala.collection.immutable.sortedmap","scala.collection.immutable.sortedmap[string,int])]","scala.collection.map[string,scala.collection.immutable.sortedmap[string,int]]","scala.collection.map[user,transactioncount]","section","semigroup","set","show","shuffledrdd[15]","shuffledrdd[17]","simplifi","sort","sortedmap(\"task1\"","sortedmap(\"task3\"","spark","sparkdelay","sparkdelay[f].","sparksess","sparksession,","sparksession.","stack","stack.","stack:","string","string)]","string)],","string]","suppli","suspend","suspended.","suspens","syntax","t]","task","task2","task3","those","thread","timeseri","timeseries)]","togeth","together.","totalperus","totalperuser.collectasmap","totalperuser:","transactioncount","transactioncount)]","tupl","two","type","type.","typeclass","typedd","typeddataset","typeddataset.create(seq((1,","typedds:","us","user","user'","usernam","util","val","valu","variabl","way","work","work,","wrap","yet.","{","|+|"],"TypedML.html":["\"\",","\"lyon\",","\"san","(0","(empti","(name","(repres","(see","(sinc","(the","(what","(which",")","))","...",".as[housedatawithfeatures]","//","0)))","1","1,","1.0","100000)))","100000),","1:","2","2))","2,","2.0","200000),","250000),","2:","3","3)","3.0.0):","3.1.0.","4","500000)","500000),","800000)))","900000)",":)",":37:",":39:",":40:","=",">","[1.0,2.0,3.0]","[_1:","[features:","[squarefeet:","^","_2:","`labels`","`labelsarray`","abov","abstract","accept","add","another,","api","api,","append","array","array(1,","as:","assembl","assembler.transform(testdata).as[housedatawithfeatures]","assembler.transform(trainingdata)","assembler.transform(trainingdata).as[housedatawithfeatures]","assembler.transform(trainingdata).as[wronghousefeatures]","assembler.transform(wrongtrainingdata)","assembler:","back","base","boolean","boolean)","boolean,","boolean:","both","call","calls,","case","case)","cast","categor","check","citi","city.","city:","cityindexed:","class","close","code","column(s)","column(s).","companion","compil","comput","contain","continu","contrari","contribut","correct","current","data","data)","data,","datafram","datawithfeatur","datawithfeatures:","deal","default","defin","depend","deprec","deriv","detail","document","doubl","double)","double,","double]","encod","equival","error:","estimator.","estimators.","exampl","example,","exclus","fact","false,","featur","features(price:","features(squarefeet:","features).","features):","features.","features:","feed","field","field]","fields]","find","fit","footag","footage.","forest,","frameless","frameless._","frameless.ml._","frameless.ml.appendtransformer[rfinputs,frameless.ml.classification.typedrandomforestclassifier.outputs,org.apache.spark.ml.classification.randomforestclassificationmodel]","frameless.ml.appendtransformer[rfinputs,frameless.ml.regression.typedrandomforestregressor.outputs,org.apache.spark.ml.regression.randomforestregressionmodel]","frameless.ml.appendtransformer[stringindexerinput,frameless.ml.feature.typedstringindexer.outputs,org.apache.spark.ml.feature.stringindexermodel]","frameless.ml.classification._","frameless.ml.classification.typedrandomforestclassifier@33ab9b32","frameless.ml.classification.typedrandomforestclassifier[rfinputs]","frameless.ml.feature._","frameless.ml.feature.typedindextostring@355dd92d","frameless.ml.feature.typedindextostring[indextostringinput]","frameless.ml.feature.typedstringindexer@4c2621e0","frameless.ml.feature.typedstringindexer[stringindexerinput]","frameless.ml.feature.typedvectorassembler@a559710","frameless.ml.feature.typedvectorassembler@eb06753","frameless.ml.feature.typedvectorassembler[features]","frameless.ml.regression._","frameless.ml.regression.typedrandomforestregressor@37d61f51","frameless.ml.regression.typedrandomforestregressor[rfinputs]","frameless.ml.typedestimator$$anon$1@5bd75b8","frameless.ml.typedestimator$$anon$1@5d5c3","frameless.ml.typedestimator$$anon$1@6145e82d","frameless.ops.as[(double,","frameless.syntax._","frameless.typeddataset[(string,","frameless.typeddataset[housecityprediction]","frameless.typeddataset[housecitypredictionindexed]","frameless.typeddataset[housecitypredictioninputs]","frameless.typeddataset[housedata]","frameless.typeddataset[housedatawithfeatures]","frameless.typeddataset[housedatawithfeaturesandindex]","frameless.typeddataset[housepriceprediction]","frameless.typeddataset[wronghousedata]","francisco\",","francisco)","from)","garden","hasgarden","hasgarden:","here","hood,","hous","housecitypredict","housecityprediction(","housecitypredictionindex","housecitypredictionindexed(","housecitypredictioninput","housecitypredictioninputs(features:","housedata","housedata(100,","housedata(150,","housedata(20,","housedata(200,","housedata(50,","housedata(squarefeet:","housedata?","housedatawithfeatur","housedatawithfeatures(squarefeet:","housedatawithfeaturesandindex","housedatawithfeaturesandindex(","housepricepredict","housepriceprediction(","i.","ignor","implement","implicit","import","index","indexeddata","indexeddata:","indexedpredict","indexedpredictions:","indexedtestdata","indexedtestdata.project[housecitypredictioninputs]","indexedtestdata:","indexer.estimator.sethandleinvalid(\"keep\")","indexer.estimator.typ","indexer.fit(datawithfeatures).run()","indexer:","indexermodel","indexermodel.transform(datawithfeatures).as[housedatawithfeaturesandindex]","indexermodel.transform(testdatawithfeatures).as[housedatawithfeaturesandindex]","indexermodel:","indextostr","indextostring.transform(indexedpredictions).as[housecityprediction]","indextostring:","indextostringinput","indextostringinput(predictedcityindexed:","input","instanc","instead.","int,","introduc","it.","label","label)","label):","label,","level","leverag","list","locat","lowest","make","matrices.dense(2,","matrix","matrix))","matrix:","matrix]","matrixd","matrixds:","member","method","miss","ml","ml'","model","model.","model.transform(testdata)","model.transform(testdatawithfeatures)","model.transform(testdatawithfeatures).as[housepriceprediction]","model.transform(testinput).as[housecitypredictionindexed]","model:","modul","more","moreover,","name","need","new","not.","now","numer","object.","on","order","org.apache.spark.ml.linalg._","org.apache.spark.ml.linalg.matrix","org.apache.spark.ml.linalg.matrix)]","org.apache.spark.ml.linalg.matrix:","org.apache.spark.ml.linalg.matrixudt.","org.apache.spark.ml.linalg.vector","org.apache.spark.ml.linalg.vector),wronghousefeatures]","org.apache.spark.ml.linalg.vector)]","org.apache.spark.ml.linalg.vectorudt","org.apache.spark.sql.types.userdefinedtype[a]","overview):","paramet","pass","perhap","pleas","possibl","predict","predict).","predictedcity:","predictedcityindexed.","predictedcityindexed:","predictedprice:","predictions.select(predictions.col('predictedcity)).collect.run()","predictions.select(predictions.col('predictedprice)).collect.run()","predictions:","previou","previous","price","price:","probability:","project","prove","provid","random","rawprediction:","remov","repres","res6:","res8:","res9:","return","reus","rf","rf.fit(indexeddata).run()","rf.fit(trainingdatawithfeatures)","rf.fit(trainingdatawithfeatures).run()","rf.fit(wrongtrainingdatawithfeatures)","rf:","rfinput","rfinputs(cityindexed:","rfinputs(price:","rfinputs.","safe","safeti","sale","same","seq[double]","seq[string]","snippet,","spark","spark).","squar","squarefeet:","stay","stridx_267bc5cb88b4","string","string)","string,","stringindexerinput","stringindexerinput(city:","stringindexermodel","strongli","structur","subsequ","take","term","test","testdata","testdata.","testdata:","testdatawithfeatur","testdatawithfeatures:","testinput","testinput:","thank","then,","time","time.","train","trainingdata","trainingdata:","trainingdatawithfeatur","trainingdatawithfeatures:","transform","true,","type","type.","typeddataset","typeddataset'","typeddataset.","typeddataset.create(seq(","typeddataset.create(seq(\"label\"","typeddataset.create(seq(housedata(120,","typeddataset.create(seq(housedata(20,","typeddataset.create(seq(housedata(70,","typeddataset.create(seq(wronghousedata(20,","typeddataset:","typeddatasets.","typedencod","typedencoder[a]","typedestim","typedestimator,","typedestimators,","typedindextostr","typedindextostring[indextostringinput](indexermodel.transformer.labels)","typedrandomforestclassifi","typedrandomforestclassifier.","typedrandomforestclassifier[rfinputs]","typedrandomforestregressor","typedrandomforestregressor.","typedrandomforestregressor[rfinputs]","typedrandomforestregressor[wrongrfinputs]","typedstringindex","typedstringindexer[stringindexerinput]","typedtransform","typedtransformercan","typedvectorassembl","typedvectorassembler[features]","typedvectorassembler[wrongfeatures]","types)","types,","types.","under","us","usual","val","valid","valu","vector","vector)","vector))","vector,","vector:","vector]","vectorassembl","vectorassembler)","vectorassembler.transform(testdata).as[housedatawithfeatures]","vectorassembler.transform(trainingdata).as[housedatawithfeatures]","vectorassembler:","vectord","vectords:","vectors.dense(1,","vectors:","veri","want","warning:","wrappedarray(296250.0)","wrappedarray(san","wrong","wrongfeatur","wrongfeatures(squarefeet:","wronghousedata","wronghousedata(squarefeet:","wronghousedata?","wronghousefeatures(","wrongrfinput","wrongrfinputs(labelofwrongtype:","wrongtrainingdata","wrongtrainingdata:","wrongtrainingdatawithfeatur","wrongtrainingdatawithfeatures:"],"TypedDataFrame.html":["\"dummy\"","\"unique\"","').map(r","'_4)","'q',","'s)","'x',","'z'))","'z'.","(((((((((","(implicit","(phonebooktf:",")",".as[family]()",".as[neighborhoodcount]()",".filter",".flatmap",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select('_2,",".select('neighborhood)",".sortdesc('count)","//","1.6","1.6+,","1.6,","11","2.10,","2.11","2.11,","22.",":",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","=>","???","addit","address","address,","address:","alphabet:","alternatively,","amount","api","approach","approxim","ariti","avail","away:","b:","bar(i:","bestneighborhood","boolean","boolean)","boolean):","boolean)]","boolean,","both","bring","c:","call","case","catch","caught","caus","citi","citymapentry(","citymaptf:","class","column","columns.","come","common","commonli","compar","compat","compil","complet","comput","concept:","consid","consist","contain","conveni","correct","count:","d:","data","datafram","dataframe,","dataframes,","dataset","def","defin","definit","deprec","design","develop","differ","directli","dive","document.","domain","done","doubl","double,","due","each","earli","element","enough","ensur","essenti","everyth","exampl","example:","except","execut","exist","expect","f","f.neighborhood))","f.residents.split('","fact","family(residents:","field","filter(conditionexpr:","first","flat","focu","follow","foo(s:","frameless","frameless.","frameless.typeddatafram","frameless:","function","further","futur","get","go","goal","goe","handl","have","here","hold","however,","i:","ident","import","improv","inform","instead","int)","int,","interest","intermedi","introduc","introduct","invalid","j:","job","jobs.","join","join1(tf1:","join2(tf1:","joins,","keep","languag","less","let","let'","letter","level","leverag","librari","like,","limit","limitations.","line","long)","long)])","look","main","manag","manipul","manner.","map","mirror","mistak","model","moder","more","much","name","name.exists(set('x',","names,","natur","need","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","neighborhoods:","nlplib","nlplib.uniquename(p.name)","now","number,","object","obtain","ontypeddataframe.","onward.","org.apache.spark.sql.datafram","org.apache.spark.sql.sqlcontext","p","packag","pair","person(name:","person(r,","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","point,","possibl","process","product.","proof","provid","public","readability.","readabl","reasons,","refer","referenc","represent","residents:","result","rethought","return","right","sadly,","safe","safety.","scala","schema","schema.","second","see","see,","seem","select","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","shadow","shapeless.hlist","signatures:","similar","simplifi","singl","spark","spark'","spark,","sqlcontext):","stage","still","store","string","string):","string)]","string)])","string,","suppos","syntax","syntaxes.","system","systems,","tabl","table,","tables:","target","tdataframe[schema","tdataframe[schema]","techniqu","test.","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","time.","track","troubl","tuple23","two","type","type,","type.","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry])","typeddataframe[citymapentry].","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","types:","typo,","uniqu","uniquename(name:","us","user","valu","vanilla","variou","veri","version","way","well,","won't","work","zero.","{","}"]},"length":9},"tokenStore":{"root":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},".":{"0":{"docs":{},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"1":{"3":{"docs":{},".":{"1":{"3":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"docs":{}},"docs":{}}},"docs":{}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"4":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"1":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}}},"5":{"docs":{},".":{"2":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{},"x":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"6":{"docs":{},".":{"1":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{},"x":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"7":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}}},"8":{"docs":{"./":{"ref":"./","tf":0.00684931506849315}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}}},"9":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{},"x":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"docs":{}},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"1":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"i":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}},"x":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}}},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195}}}},"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"5":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"9":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.010471204188481676},"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}},".":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}}},"1":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"6":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"+":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"docs":{},"x":{"docs":{"./":{"ref":"./","tf":0.02054794520547945}}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.007853403141361256},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},")":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"docs":{}},"docs":{}},"docs":{}},"2":{"1":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},"docs":{}},"docs":{"./":{"ref":"./","tf":0.00228310502283105}},":":{"2":{"9":{"docs":{},":":{"1":{"1":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"%":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"2":{"2":{"9":{"6":{"2":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}},"}":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"4":{"0":{"9":{"docs":{},".":{"6":{"3":{"8":{"5":{"5":{"4":{"2":{"1":{"6":{"8":{"6":{"7":{"3":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},")":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"{":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"|":{"docs":{},"[":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"9":{"5":{"5":{"docs":{},".":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"5":{"7":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.005421686746987952},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"1":{"0":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"1":{"docs":{"./":{"ref":"./","tf":0.01141552511415525},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"/":{"2":{"docs":{},".":{"1":{"2":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}},"docs":{}}},"docs":{}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"2":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},".":{"docs":{},"x":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"docs":{}},"2":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}},"1":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}},"docs":{}}},"3":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"1":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"2":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"docs":{}}},"4":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}}},"docs":{}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}}}}}}}}}}}}},"#":{"1":{"6":{"5":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"docs":{}},"docs":{}},"docs":{}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002710843373493976}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}},"}":{"docs":{},"|":{"docs":{},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"{":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"4":{"3":{"6":{"2":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"}":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},".":{"0":{"docs":{},".":{"0":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}},")":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"docs":{}}},"1":{"docs":{},".":{"0":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}}},"docs":{}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"4":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"3":{"9":{"1":{"docs":{},".":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"1":{"8":{"9":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},".":{"docs":{},".":{"docs":{},"|":{"docs":{},"{":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"7":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"docs":{}},"docs":{}},"7":{"1":{"5":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"}":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"docs":{}},"docs":{}},"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"6":{"8":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"7":{"4":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"8":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"|":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"\"":{"0":{"docs":{},".":{"9":{"docs":{},".":{"0":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"docs":{}}},"docs":{}}},"docs":{},"_":{"1":{"docs":{},"\"":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"docs":{}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.00684931506849315}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.00684931506849315}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"b":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}}}}}},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"e":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"q":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"w":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"m":{"docs":{},"y":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"a":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"2":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"docs":{}}}}},"\"":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"\"":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"%":{"docs":{"./":{"ref":"./","tf":0.00684931506849315}},"%":{"docs":{"./":{"ref":"./","tf":0.00684931506849315}}}},"(":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},",":{"0":{"docs":{},",":{"0":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}}},"docs":{}}},"docs":{}}},"1":{"0":{"docs":{},",":{"9":{"docs":{},",":{"9":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}}},"docs":{}}},"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"2":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"8":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{},"e":{"docs":{},".":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},",":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}},"n":{"docs":{},"j":{"docs":{},"o":{"docs":{},"y":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"t":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},".":{"docs":{},"e":{"docs":{},".":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"#":{"2":{"3":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738}}}},"docs":{}},"docs":{}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"2":{"3":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}},"docs":{}},"docs":{}}}}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.004724409448818898}}}}},"a":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"docs":{}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"1":{"6":{"6":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}},"u":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"e":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"q":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"docs":{}}}}}}}},"i":{"docs":{},"n":{"docs":{},"c":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"u":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"w":{"docs":{},"h":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"a":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"2":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"\"":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}}}}}},"c":{"docs":{},"h":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047}}}}},"h":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"j":{"docs":{},"o":{"docs":{},"h":{"docs":{},"n":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"docs":{}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"+":{"1":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.09096385542168675},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.03888419273034658}},"+":{"docs":{},"=":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"/":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759}},"/":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.13343373493975905},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.1327134404057481},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.030120481927710843},"Injection.html":{"ref":"Injection.html","tf":0.0755287009063444},"Job.html":{"ref":"Job.html","tf":0.025210084033613446},"Cats.html":{"ref":"Cats.html","tf":0.05235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":0.05826771653543307},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"=":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.02469879518072289},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.011834319526627219},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.024096385542168676},"Injection.html":{"ref":"Injection.html","tf":0.06042296072507553},"Job.html":{"ref":"Job.html","tf":0.029411764705882353},"Cats.html":{"ref":"Cats.html","tf":0.041884816753926704},"TypedML.html":{"ref":"TypedML.html","tf":0.048818897637795275},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0166358595194085}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0084530853761623}},"=":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738}}}},">":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Injection.html":{"ref":"Injection.html","tf":0.01812688821752266},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}}},">":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.05235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"=":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"a":{"docs":{},"c":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}},"p":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"h":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}},"e":{"docs":{},"l":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}},"j":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"v":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}},"g":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"g":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738},"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"x":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},".":{"docs":{},"c":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"g":{"docs":{},"e":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"i":{"docs":{"./":{"ref":"./","tf":0.0091324200913242},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0036144578313253013},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"c":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"d":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}},"r":{"docs":{},"o":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"x":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"n":{"docs":{},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}},"t":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}},"s":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},".":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"p":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"u":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},".":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},".":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"3":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"a":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"y":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"b":{"docs":{},"i":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}},"g":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}}},"2":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"(":{"1":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{},"(":{"docs":{},"j":{"docs":{},"o":{"docs":{},"e":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"docs":{}}}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"u":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"[":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}},"v":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}},"o":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"4":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},")":{"docs":{},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"o":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"i":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"/":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"n":{"docs":{},"o":{"docs":{},"y":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"/":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}},"a":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"m":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"w":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"b":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"(":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},".":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}},"docs":{}}},"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}},"c":{"docs":{},"k":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"n":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"s":{"docs":{},"#":{"1":{"3":{"8":{"7":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}}},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"'":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}},"3":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"s":{"docs":{},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},"\"":{"docs":{},".":{"docs":{},"i":{"docs":{},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"o":{"docs":{},"w":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"w":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"o":{"docs":{},"o":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.005511811023622047},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}}},"y":{"docs":{},"p":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},")":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"s":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002710843373493976},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"(":{"1":{"0":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"docs":{}},"2":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"docs":{}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0051204819277108436},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.02108433734939759},"Injection.html":{"ref":"Injection.html","tf":0.03927492447129909},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.014960629921259842},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.018484288354898338}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.02054794520547945},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":3.347731239092495}},"s":{"docs":{},"\"":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"e":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"[":{"docs":{},"f":{"docs":{},"]":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}},"o":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}},"m":{"docs":{},"t":{"docs":{},"l":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"g":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}},"r":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"p":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}}}}},"o":{"docs":{},"o":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007228915662650603},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0076077768385460695},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.03313253012048193},"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.028346456692913385},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.022181146025878003}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"u":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"o":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"(":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.010542168674698794},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0076077768385460695},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012939001848428836}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5016906170752327},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"i":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"n":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0091324200913242},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0076077768385460695},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012048192771084338},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedML.html":{"ref":"TypedML.html","tf":0.004724409448818898},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"l":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"x":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"o":{"docs":{},"f":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"i":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"e":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}}}}}},"o":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"m":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351817621688227}}}}}},"a":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"o":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"o":{"docs":{},"r":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.005511811023622047},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"i":{"docs":{},"b":{"docs":{},"u":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"n":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"i":{"docs":{},"n":{"docs":{},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"u":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"v":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"p":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"p":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Injection.html":{"ref":"Injection.html","tf":2.512084592145015}}}}}},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}},"s":{"docs":{},"t":{"docs":{},"o":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":2.503021148036254}},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}}}}},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}}}}},"docs":{}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"1":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.007874015748031496}}},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"2":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"1":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"3":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"docs":{}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"(":{"3":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"4":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.005511811023622047}}}}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"1":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"3":{"docs":{},"|":{"docs":{},"a":{"docs":{},"v":{"docs":{},"g":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"4":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.012939001848428836}},"e":{"docs":{},"'":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.01598173515981735},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.507607776838546},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"\"":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"/":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"[":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"?":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}}}}}}}}}}}}},"y":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"b":{"docs":{},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014787430683918669}},"a":{"docs":{},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0033132530120481927},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.03323262839879154},"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047},"TypedML.html":{"ref":"TypedML.html","tf":0.013385826771653543},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.01598173515981735},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}}}},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"p":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}}}}}},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"s":{"docs":{},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018072289156626505},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"o":{"docs":{},"c":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"n":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"'":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0033132530120481927},"TypedML.html":{"ref":"TypedML.html","tf":0.007086614173228346},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedML.html":{"ref":"TypedML.html","tf":0.004724409448818898}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00391566265060241},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.027559055118110236},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"m":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"]":{"docs":{},"|":{"docs":{},"t":{"docs":{},"r":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"i":{"docs":{},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"u":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"(":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"/":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"/":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}},"_":{"docs":{},".":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.02108433734939759},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"u":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"r":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.007853403141361256}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3544176706827304},"Injection.html":{"ref":"Injection.html","tf":2.512084592145015},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}},"[":{"docs":{},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"s":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"v":{"docs":{},"i":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}}}}},"t":{"docs":{},"i":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"h":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004216867469879518},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005917159763313609},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"TypedML.html":{"ref":"TypedML.html","tf":0.004724409448818898}}}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"s":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"n":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"i":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}},"_":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}}}}}},"o":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"l":{"docs":{},"u":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"e":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106}}}}}},"h":{"docs":{},"a":{"docs":{},"u":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},".":{"docs":{},"g":{"docs":{},".":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"[":{"1":{"3":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}},"docs":{}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"o":{"docs":{},"(":{"docs":{},"i":{"docs":{},",":{"1":{"0":{"docs":{},")":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}},"docs":{}},"docs":{}}}}}}}}}},"t":{"docs":{},"c":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"$":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}}}}}}},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.33363453815261},"TypedML.html":{"ref":"TypedML.html","tf":0.010236220472440945}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}},")":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.009448818897637795}}}}}}}}},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"w":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106}},"e":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"_":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0033132530120481927},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.008661417322834646},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00391566265060241},"TypedML.html":{"ref":"TypedML.html","tf":0.007086614173228346}}}}}}},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}}}}}},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"a":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.005917159763313609},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{},"i":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"i":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"c":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.05251141552511415},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002710843373493976},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3423694779116464},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"_":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"_":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},"_":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"_":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}}}}}}}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"?":{"docs":{},"t":{"docs":{},",":{"docs":{},"?":{"docs":{},"c":{"docs":{},"[":{"docs":{},"?":{"docs":{},"a":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"t":{"docs":{},",":{"docs":{},"c":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"c":{"docs":{},"]":{"docs":{},")":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"[":{"docs":{},"t":{"docs":{},",":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},",":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"_":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"{":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"=":{"docs":{},">":{"docs":{},"f":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"}":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}},"w":{"docs":{},"h":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"d":{"docs":{},"f":{"docs":{},"$":{"docs":{},"$":{"docs":{},"l":{"docs":{},"a":{"docs":{},"m":{"docs":{},"b":{"docs":{},"d":{"docs":{},"a":{"docs":{},"$":{"1":{"2":{"5":{"4":{"9":{"docs":{},"/":{"0":{"docs":{},"x":{"0":{"0":{"0":{"0":{"0":{"0":{"0":{"8":{"0":{"3":{"8":{"9":{"8":{"8":{"4":{"0":{"docs":{},"@":{"6":{"1":{"5":{"2":{"1":{"3":{"9":{"7":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"t":{"docs":{},",":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"?":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}}},"d":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"t":{"docs":{},"h":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"?":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"t":{"docs":{},"t":{"docs":{},"]":{"docs":{},"{":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},",":{"docs":{},"t":{"docs":{},"t":{"docs":{},"]":{"docs":{},"{":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}}}}}}}}},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"2":{"docs":{},"@":{"1":{"2":{"3":{"4":{"1":{"6":{"docs":{},"f":{"3":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"4":{"docs":{},"@":{"7":{"7":{"docs":{},"b":{"docs":{},"c":{"docs":{},"a":{"0":{"docs":{},"d":{"3":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"docs":{}}},"docs":{}}}}},"docs":{}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}},"_":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"i":{"docs":{},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"7":{"docs":{},"c":{"0":{"docs":{},"f":{"docs":{},"b":{"docs":{},"e":{"0":{"2":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"docs":{}},"docs":{}}}}},"docs":{}},"d":{"7":{"1":{"6":{"4":{"7":{"7":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}}}}}}}},"[":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"@":{"3":{"3":{"docs":{},"a":{"docs":{},"b":{"9":{"docs":{},"b":{"3":{"2":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}},"docs":{}}},"docs":{}}}},"docs":{}},"docs":{}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"@":{"3":{"5":{"5":{"docs":{},"d":{"docs":{},"d":{"9":{"2":{"docs":{},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"@":{"4":{"docs":{},"c":{"2":{"6":{"2":{"1":{"docs":{},"e":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"r":{"docs":{},"@":{"docs":{},"a":{"5":{"5":{"9":{"7":{"1":{"0":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"e":{"docs":{},"b":{"0":{"6":{"7":{"5":{"3":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}},"[":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"@":{"3":{"7":{"docs":{},"d":{"6":{"1":{"docs":{},"f":{"5":{"1":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"5":{"docs":{},"b":{"docs":{},"d":{"7":{"5":{"docs":{},"b":{"8":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}}},"docs":{}},"docs":{}}},"d":{"5":{"docs":{},"c":{"3":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}}},"docs":{}}},"6":{"1":{"4":{"5":{"docs":{},"e":{"8":{"2":{"docs":{},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"\"":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}},"e":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"i":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"o":{"docs":{},"m":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0030120481927710845},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"(":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}},"r":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"l":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"y":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"4":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"(":{"docs":{},"f":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},"+":{"2":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"f":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"f":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"}":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"[":{"docs":{},"_":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"a":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"l":{"docs":{},")":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015105740181268883}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133}}},"t":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},".":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"8":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"docs":{}}},"h":{"docs":{},"u":{"docs":{},"b":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"v":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"b":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}},"o":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"a":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"e":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"?":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"t":{"docs":{},"t":{"docs":{},"p":{"docs":{},":":{"docs":{},"/":{"docs":{},"/":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"o":{"docs":{},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"/":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"h":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}},"v":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"s":{"docs":{},"g":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.009448818897637795}}}}}}}}}}},"o":{"docs":{},"w":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"o":{"docs":{},"d":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"u":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"s":{"docs":{},"(":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},"(":{"1":{"0":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{}},"2":{"0":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"5":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"docs":{}},"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}},"?":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"c":{"docs":{},"h":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"s":{"docs":{},"/":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"g":{"8":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}},"docs":{}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012048192771084338},"Injection.html":{"ref":"Injection.html","tf":0.015105740181268883},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"l":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"docs":{}},"6":{"7":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"docs":{}},"docs":{}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.007228915662650603},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01098901098901099},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.015060240963855422},"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.032722513089005235},"TypedML.html":{"ref":"TypedML.html","tf":0.007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}}}},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}}}}}},"n":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.015105740181268883}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Injection.html":{"ref":"Injection.html","tf":2.503021148036254}}},"(":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}},"j":{"docs":{},"a":{"docs":{},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"n":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"m":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"g":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"t":{"docs":{"./":{"ref":"./","tf":10},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253},"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106},"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"u":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"a":{"docs":{},"l":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},"s":{"docs":{},".":{"docs":{},"w":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.007086614173228346}},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"[":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"e":{"docs":{},":":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"(":{"docs":{},"b":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"l":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}},"r":{"docs":{},".":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"i":{"docs":{},"n":{"docs":{},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"k":{"docs":{},"e":{"docs":{},"e":{"docs":{},"p":{"docs":{},"\"":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"/":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}}}},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"f":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"g":{"docs":{},"n":{"docs":{},"o":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}},"t":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}},"o":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"j":{"docs":{},"a":{"docs":{},"r":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"v":{"docs":{},"a":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{},".":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"_":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},"l":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.015060240963855422}}},".":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}}}}}}}}},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"o":{"docs":{},"b":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Job.html":{"ref":"Job.html","tf":10.004201680672269}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}},"s":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},"i":{"docs":{},"n":{"1":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}}}}},"2":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"1":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.011090573012939002}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"]":{"docs":{},";":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"v":{"docs":{},"m":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},"v":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}},"n":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"e":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"e":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"s":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}}}}}},"i":{"docs":{},"b":{"docs":{},"r":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"y":{"docs":{},"d":{"docs":{},"e":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"c":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.0091324200913242}}}}}},"s":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"(":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}}}},"t":{"docs":{},"u":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}},"f":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"t":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"0":{"1":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}},"docs":{}},"docs":{}}},"1":{"docs":{},".":{"1":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"docs":{}}},"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"1":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},",":{"4":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"b":{"docs":{},"c":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"u":{"docs":{},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"k":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},"o":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"s":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"w":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"z":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}},"l":{"docs":{},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"y":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"r":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"n":{"docs":{},"g":{"docs":{},"u":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"1":{"3":{"3":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"8":{"2":{"docs":{},".":{"5":{"9":{"7":{"0":{"5":{"4":{"8":{"8":{"6":{"2":{"1":{"1":{"5":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"m":{"docs":{},"a":{"docs":{},"d":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"r":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"h":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047}}}}}}},"n":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"(":{"0":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.007853403141361256}}},"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}},"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"docs":{}}}}}},"e":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"2":{"3":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"2":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}}}}}}}}}}},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},")":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"l":{"docs":{},"e":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106}},")":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},"x":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"e":{"docs":{},"r":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}},"s":{"docs":{},"s":{"docs":{},"a":{"docs":{},"g":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}}}}},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"c":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}}}},"a":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"u":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"[":{"docs":{},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"c":{"docs":{},"h":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"t":{"docs":{},"a":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"l":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"TypedML.html":{"ref":"TypedML.html","tf":2.511023622047244}},"\"":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"'":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.0091324200913242},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.011811023622047244},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"o":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{},"i":{"docs":{},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"c":{"docs":{},"h":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},"e":{"docs":{},"(":{"docs":{},"j":{"docs":{},"d":{"docs":{},"a":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}},"t":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"e":{"docs":{},"e":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"w":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018072289156626505},"Injection.html":{"ref":"Injection.html","tf":0.012084592145015106},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"i":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}},"x":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"s":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}}},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"t":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"h":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"w":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"r":{"docs":{},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"u":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"l":{"docs":{},"l":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507}}},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"s":{"docs":{},"/":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"b":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"p":{"docs":{},".":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"f":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},")":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"l":{"docs":{},"i":{"docs":{},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"r":{"docs":{},"b":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"v":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}}}}}}}}}},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},"(":{"1":{"docs":{},",":{"2":{"docs":{},",":{"3":{"docs":{},",":{"4":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}},"c":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"Cats.html":{"ref":"Cats.html","tf":0.010471204188481676}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}},"n":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"(":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"x":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006762468300929839}},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"o":{"docs":{},"f":{"docs":{},"m":{"docs":{},"e":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}}}}}}}}}},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"v":{"docs":{},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.33363453815261}},")":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"l":{"docs":{},"o":{"docs":{},"a":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}},"f":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},"a":{"docs":{},"l":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"docs":{},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"x":{"docs":{},"c":{"docs":{},"e":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"$":{"2":{"2":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"5":{"0":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"1":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"4":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"5":{"0":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"7":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"5":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"5":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"8":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"7":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},"$":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"$":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"$":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"$":{"docs":{},"c":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"t":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},"$":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"9":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"5":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"$":{"docs":{},"n":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"$":{"2":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"5":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"1":{"2":{"docs":{},"$":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"5":{"docs":{},"$":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"docs":{},"$":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"5":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"2":{"9":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"6":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"7":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"$":{"docs":{},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"0":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"a":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"i":{"docs":{},"n":{"docs":{},"v":{"docs":{},"o":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"2":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"2":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"3":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"docs":{},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"i":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"1":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"3":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"3":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"4":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"3":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"3":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"7":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"3":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"1":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"docs":{}},"s":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"4":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"m":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"1":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"$":{"1":{"docs":{},"$":{"docs":{},"a":{"docs":{},"d":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"0":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"1":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"2":{"docs":{},"(":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"1":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"0":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"k":{"docs":{},"(":{"docs":{},"r":{"docs":{},"u":{"docs":{},"l":{"docs":{},"e":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"u":{"docs":{},"r":{"docs":{},"r":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"$":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"$":{"2":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"4":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"8":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"4":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"u":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"4":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"y":{"docs":{},"(":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"6":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"9":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"6":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"7":{"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"2":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"9":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"3":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"1":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"n":{"docs":{},"u":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"s":{"docs":{},"$":{"docs":{},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"0":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"0":{"4":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"$":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"0":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"s":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"8":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"4":{"6":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"5":{"1":{"7":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"p":{"docs":{},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"7":{"1":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"1":{"0":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"6":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}},"[":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"g":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},".":{"docs":{},"r":{"docs":{},"o":{"docs":{},"w":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},"$":{"docs":{},".":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"g":{"docs":{},"e":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"r":{"docs":{},"o":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"4":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"$":{"docs":{},"l":{"docs":{},"z":{"docs":{},"y":{"docs":{},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"y":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"e":{"docs":{},"p":{"docs":{},"h":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"r":{"docs":{},"y":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"c":{"docs":{},"u":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"4":{"3":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"$":{"docs":{},".":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"{":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"v":{"docs":{},"e":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"7":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"3":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"o":{"docs":{},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"$":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"5":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"l":{"docs":{},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"5":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"e":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"d":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"{":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},".":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"l":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},"g":{"docs":{},".":{"docs":{},"_":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"m":{"docs":{},"a":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},")":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"u":{"docs":{},"d":{"docs":{},"t":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},")":{"docs":{},",":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"u":{"docs":{},"d":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"8":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}}}}}},"docs":{}}},"docs":{}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"b":{"docs":{},"j":{"docs":{},"#":{"7":{"2":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"3":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253},"Injection.html":{"ref":"Injection.html","tf":0.01812688821752266},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"t":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"k":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"o":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"r":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"l":{"docs":{},"y":{"docs":{},"m":{"docs":{},"o":{"docs":{},"r":{"docs":{},"p":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},"e":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}},"v":{"docs":{},"i":{"docs":{},"o":{"docs":{},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}},"c":{"docs":{},"i":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.011811023622047244}},")":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"(":{"docs":{},"'":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}},"o":{"docs":{},"b":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"a":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0091324200913242},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0024096385542168677},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"/":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.3351817621688227}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}},"l":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"v":{"docs":{},"i":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"g":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"m":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}},"c":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedML.html":{"ref":"TypedML.html","tf":0.004724409448818898}},"#":{"1":{"3":{"8":{"6":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"/":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.007086614173228346}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"b":{"docs":{},"y":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"u":{"docs":{},"n":{"docs":{},"i":{"docs":{},"t":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"3":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"(":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"n":{"docs":{},"t":{"docs":{},"l":{"docs":{},"n":{"docs":{},"(":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"m":{"docs":{},"a":{"docs":{},"x":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.0045662100456621}}}},"s":{"docs":{},"h":{"docs":{},"e":{"docs":{},"d":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}}}}}}},"b":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"2":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"4":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"6":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"8":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"9":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"i":{"docs":{},"c":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01014370245139476}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"i":{"docs":{},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"c":{"docs":{},"k":{"docs":{},"a":{"docs":{},"g":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"a":{"docs":{},"n":{"docs":{},"c":{"docs":{},"e":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133}},"(":{"docs":{},"a":{"docs":{},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"r":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.01812688821752266}},"s":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}},"i":{"docs":{},"v":{"docs":{},"o":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"h":{"docs":{},"y":{"docs":{},"s":{"docs":{},"i":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738}}}}}},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"(":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"t":{"docs":{},"f":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"n":{"docs":{},"u":{"docs":{},"m":{"docs":{},"b":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"c":{"docs":{},"e":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"i":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"s":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}},"q":{"docs":{},"u":{"docs":{},"i":{"docs":{},"c":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"r":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"d":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"Cats.html":{"ref":"Cats.html","tf":3.338568935427574}},"s":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},",":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253}}}}}}},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"#":{"2":{"3":{"docs":{},"l":{"docs":{},",":{"docs":{},"j":{"docs":{},"#":{"2":{"4":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"docs":{}},"docs":{}}}}}},"docs":{}},"docs":{}}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"s":{"docs":{},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"i":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}},"a":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}},"e":{"docs":{},"r":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"[":{"docs":{},"i":{"docs":{},"o":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}},"a":{"docs":{},"b":{"docs":{},"i":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"c":{"docs":{},"o":{"docs":{},"m":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"u":{"docs":{},"r":{"docs":{},"s":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},"m":{"docs":{},"o":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},".":{"docs":{},"u":{"docs":{},"i":{"docs":{},".":{"docs":{},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"s":{"1":{"6":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"7":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"9":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"2":{"0":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{},":":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"3":{"0":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"3":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"4":{"5":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"5":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"6":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"8":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"9":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{},"o":{"docs":{},"l":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"u":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}},"u":{"docs":{},"l":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002710843373493976},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"s":{"docs":{},"y":{"docs":{},"n":{"docs":{},"c":{"docs":{},"(":{"docs":{},")":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"u":{"docs":{},"r":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"d":{"docs":{},"u":{"docs":{},"c":{"docs":{},"e":{"docs":{},"b":{"docs":{},"y":{"docs":{},"k":{"docs":{},"e":{"docs":{},"y":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"u":{"docs":{},"n":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838}},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}},"e":{"docs":{},".":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"a":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"w":{"docs":{},"p":{"docs":{},"r":{"docs":{},"e":{"docs":{},"d":{"docs":{},"i":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"?":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004216867469879518}}},"o":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"f":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},".":{"docs":{},"f":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}},"s":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"d":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}},"p":{"docs":{},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"!":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"m":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}}},"p":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"_":{"docs":{},".":{"docs":{},"m":{"docs":{},"i":{"docs":{},"n":{"docs":{},")":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"y":{"docs":{},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"l":{"docs":{},"e":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"d":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"b":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0091324200913242}}}},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"a":{"docs":{},"b":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"0":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"9":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"3":{"1":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"9":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"docs":{}},"3":{"0":{"5":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"l":{"docs":{},"d":{"docs":{},"l":{"docs":{},"e":{"docs":{},"f":{"docs":{},"t":{"docs":{},"$":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{},"i":{"docs":{},"z":{"docs":{},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"1":{"2":{"6":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"(":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"b":{"docs":{},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"4":{"9":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"c":{"docs":{},"h":{"docs":{},"$":{"docs":{},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"5":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"i":{"docs":{},"z":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"6":{"2":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{},"i":{"docs":{},"m":{"docs":{},"m":{"docs":{},"u":{"docs":{},"t":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},",":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"$":{"docs":{},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"u":{"docs":{},"n":{"docs":{},"$":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"1":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"$":{"docs":{},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"7":{"8":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}},"(":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{},"e":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"2":{"8":{"5":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},".":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"[":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"w":{"docs":{},",":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"n":{"docs":{},"a":{"docs":{},"l":{"docs":{},".":{"docs":{},"t":{"docs":{},"p":{"docs":{},"e":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"$":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},".":{"docs":{},"u":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"s":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"a":{"docs":{},":":{"7":{"3":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.009036144578313253}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},">":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"e":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0018072289156626507},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},".":{"docs":{},"e":{"docs":{},"m":{"docs":{},"p":{"docs":{},"t":{"docs":{},"y":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"m":{"docs":{},"a":{"docs":{},"k":{"docs":{},"e":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"(":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{},"\"":{"docs":{},"b":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"v":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0033132530120481927},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"[":{"docs":{},"c":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"o":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}},"q":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"4":{"2":{"docs":{},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}},"docs":{}},"docs":{}}}}}}}}},"[":{"docs":{},"(":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}},"u":{"docs":{},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.012605042016806723}}}}}}},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"i":{"docs":{},"z":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}},"e":{"docs":{},"f":{"docs":{},"r":{"docs":{},"o":{"docs":{},"m":{"docs":{},"o":{"docs":{},"b":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"a":{"docs":{},"l":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}},"m":{"docs":{},"i":{"docs":{},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},"h":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},".":{"docs":{},"t":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"d":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"x":{"docs":{},"\"":{"docs":{},")":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"'":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004216867469879518},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"(":{"1":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"c":{"docs":{},"a":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}},"u":{"docs":{},"f":{"docs":{},"f":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"d":{"docs":{},"d":{"docs":{},"[":{"1":{"5":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"7":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}},"docs":{}}}}}}}}}}}},"i":{"docs":{},"g":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"a":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},")":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"s":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"y":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002710843373493976},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"z":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"t":{"docs":{},"u":{"docs":{},"a":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.02511415525114155},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.01014370245139476},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Job.html":{"ref":"Job.html","tf":0.03361344537815126},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":2.5078740157480315},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.018484288354898338}},"'":{"docs":{"./":{"ref":"./","tf":0.0091324200913242},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.5050718512256975},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},")":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},".":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"s":{"docs":{},".":{"docs":{},"_":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"l":{"docs":{},"o":{"docs":{},"g":{"docs":{},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"w":{"docs":{},"a":{"docs":{},"r":{"docs":{},"n":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"q":{"docs":{},"u":{"docs":{},"e":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"/":{"docs":{},"t":{"docs":{},"m":{"docs":{},"p":{"docs":{},"/":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"m":{"docs":{},"a":{"docs":{},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"l":{"docs":{},"o":{"docs":{},"c":{"docs":{},"a":{"docs":{},"l":{"docs":{},"[":{"docs":{},"*":{"docs":{},"]":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"_":{"2":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"docs":{}}}}},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"b":{"docs":{},"u":{"docs":{},"i":{"docs":{},"l":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},"i":{"docs":{},"g":{"docs":{},"(":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"p":{"docs":{},"p":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"r":{"docs":{},"e":{"docs":{},"p":{"docs":{},"l":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},"a":{"docs":{},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"[":{"docs":{},"f":{"docs":{},"[":{"docs":{},"_":{"docs":{},"]":{"docs":{},"]":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}},"]":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}},"e":{"docs":{},"c":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"t":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"d":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"c":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},")":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"s":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"y":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"g":{"docs":{},"e":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"l":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedML.html":{"ref":"TypedML.html","tf":0.007086614173228346},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"b":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},",":{"docs":{},"u":{"docs":{},"p":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.01144578313253012},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.004724409448818898},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.014787430683918669}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}},"c":{"docs":{},"t":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"d":{"docs":{},"x":{"docs":{},"_":{"2":{"6":{"7":{"docs":{},"b":{"docs":{},"c":{"5":{"docs":{},"c":{"docs":{},"b":{"8":{"8":{"docs":{},"b":{"4":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"docs":{}}},"docs":{}},"docs":{}}}},"docs":{}}}},"docs":{}},"docs":{}},"docs":{}}}}},"u":{"docs":{},"c":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"u":{"docs":{},"i":{"docs":{},"t":{"docs":{},"e":{"docs":{},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}},"p":{"docs":{},"p":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"l":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"b":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"q":{"docs":{},"u":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}},"c":{"docs":{},"h":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"f":{"docs":{},"f":{"docs":{},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"i":{"docs":{},"c":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"g":{"docs":{},"g":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"m":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},"#":{"1":{"6":{"4":{"docs":{},"l":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"docs":{}},"docs":{}},"docs":{}}}}},"m":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"#":{"1":{"3":{"8":{"5":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00391566265060241}}},"]":{"docs":{},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"s":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"d":{"docs":{"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}},"k":{"docs":{},"i":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"o":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"1":{"0":{"docs":{},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}},"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"docs":{},")":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"e":{"docs":{},"d":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"k":{"1":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}}},"3":{"docs":{},"\"":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}}}}}}}}}}}}}},"u":{"docs":{},"r":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"l":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"v":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}},"y":{"docs":{},"m":{"docs":{},"b":{"docs":{},"o":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"n":{"docs":{},"t":{"docs":{},"a":{"docs":{},"x":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"e":{"docs":{},"s":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"e":{"docs":{},"m":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"m":{"docs":{},"a":{"docs":{},"l":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}},"n":{"docs":{},"i":{"docs":{},"p":{"docs":{},"p":{"docs":{},"e":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}}}}}}}}}}},"l":{"docs":{},"c":{"docs":{},"o":{"docs":{},"n":{"docs":{},"t":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"t":{"2":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{},"t":{"docs":{},"o":{"docs":{},"d":{"docs":{},"f":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"s":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"k":{"docs":{},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"_":{"2":{"docs":{},"\"":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"e":{"docs":{},"x":{"docs":{},"p":{"docs":{},"l":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"2":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"s":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"k":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"s":{"docs":{},"k":{"2":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"r":{"docs":{},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0045662100456621},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.005511811023622047}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"l":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"r":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"c":{"docs":{},"h":{"docs":{},"n":{"docs":{},"i":{"docs":{},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}}},"n":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}},"o":{"docs":{},"s":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"r":{"docs":{},"e":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"a":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"o":{"docs":{},"w":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"u":{"docs":{},"g":{"docs":{},"h":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}}}}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"s":{"docs":{},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"u":{"docs":{},"n":{"docs":{},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"a":{"docs":{},"n":{"docs":{},"k":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"u":{"docs":{},"n":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"p":{"docs":{},"l":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"2":{"3":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"docs":{}},"docs":{}}}},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},"a":{"docs":{},"l":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{"./":{"ref":"./","tf":0.01598173515981735},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008734939759036145},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.014370245139475908},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":3.3453815261044175},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.02356020942408377},"TypedML.html":{"ref":"TypedML.html","tf":0.015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.027726432532347505}},"d":{"docs":{},"d":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":3.344423906346272}},"e":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"[":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}},"b":{"docs":{},"a":{"docs":{},"r":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{},")":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}},"p":{"docs":{},"h":{"docs":{},"o":{"docs":{},"n":{"docs":{},"e":{"docs":{},"b":{"docs":{},"o":{"docs":{},"o":{"docs":{},"k":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"r":{"docs":{},"y":{"docs":{},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.0091324200913242},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0033132530120481927},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":2.503381234150465},"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838},"TypedML.html":{"ref":"TypedML.html","tf":2.5039370078740157}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"c":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"d":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"s":{"docs":{},"e":{"docs":{},"q":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"m":{"docs":{},"y":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}}}}}}}}}}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"docs":{}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}},"docs":{}}}}}}}}},"(":{"1":{"docs":{},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"docs":{}},"\"":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"\"":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"1":{"2":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{}},"2":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"7":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"(":{"2":{"0":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"docs":{}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"o":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.01812688821752266}}}}}}}}}}}}}}}}},":":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":3.3342369477911644},"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},"a":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"t":{"docs":{},"m":{"docs":{},"e":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"d":{"docs":{},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{},"e":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"g":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}}}}}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{},"]":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"l":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{},"n":{"docs":{},"[":{"docs":{},".":{"docs":{},".":{"docs":{},".":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}},"u":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"]":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169}}}}}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"'":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"s":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"s":{"docs":{},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"i":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},"a":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"s":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"t":{"docs":{},"o":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"m":{"docs":{},"o":{"docs":{},"d":{"docs":{},"e":{"docs":{},"l":{"docs":{},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"m":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"i":{"docs":{},"f":{"docs":{},"i":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},".":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"[":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"i":{"docs":{},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"x":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}},"e":{"docs":{},"r":{"docs":{},"c":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}},"v":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},"e":{"docs":{},"r":{"docs":{},"[":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}}}}}}}},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"l":{"docs":{},"e":{"docs":{},"v":{"docs":{},"e":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"a":{"docs":{},"f":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"e":{"docs":{},"t":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},";":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}},"e":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"d":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.012048192771084338}}}}}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"c":{"docs":{},"l":{"docs":{},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{"Job.html":{"ref":"Job.html","tf":0.01680672268907563},"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838}},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},".":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"i":{"docs":{},"m":{"docs":{},"e":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"s":{"docs":{},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}},"e":{"docs":{},"s":{"docs":{},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.005235602094240838}}}}}}}}}}}}},"o":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00391566265060241}},"i":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"g":{"docs":{},"e":{"docs":{},"t":{"docs":{},"h":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}},"y":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}},"t":{"docs":{},"a":{"docs":{},"l":{"docs":{},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"u":{"docs":{},"s":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"e":{"docs":{},"r":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}}},":":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},",":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"k":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"a":{"docs":{},"c":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}},")":{"docs":{},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133}}},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.008661417322834646}},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"u":{"docs":{},"e":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}},"o":{"docs":{},"u":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"w":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},".":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"]":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"s":{"docs":{},"c":{"docs":{},"h":{"docs":{},"e":{"docs":{},"m":{"docs":{},"a":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"]":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}},"f":{"1":{"docs":{},".":{"docs":{},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"t":{"docs":{},"f":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"'":{"docs":{},"s":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"n":{"docs":{},"d":{"docs":{},"(":{"docs":{},"'":{"docs":{},"j":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}},"2":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"docs":{},".":{"docs":{},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"'":{"docs":{},"i":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"j":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}},"u":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"n":{"docs":{},"d":{"docs":{},"e":{"docs":{},"r":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"l":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"u":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"l":{"docs":{},"y":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}}}}}}}},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}},"t":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"q":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"(":{"docs":{},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}},"l":{"docs":{},"i":{"docs":{},"k":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"s":{"docs":{},"a":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"w":{"docs":{},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"p":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},"e":{"docs":{},"d":{"docs":{},".":{"docs":{},"s":{"docs":{},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"2":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"docs":{}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}},"e":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}},"s":{"docs":{"./":{"ref":"./","tf":0.01598173515981735},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.008132530120481927},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"Job.html":{"ref":"Job.html","tf":0.02100840336134454},"Cats.html":{"ref":"Cats.html","tf":3.3424956369982546},"TypedML.html":{"ref":"TypedML.html","tf":2.5118110236220472},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.009242144177449169}},"a":{"docs":{},"g":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"e":{"docs":{},"r":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"'":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}}}}}},"u":{"docs":{},"a":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}},"d":{"docs":{},"f":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"i":{"docs":{"Job.html":{"ref":"Job.html","tf":0.008403361344537815}}},"t":{"docs":{},"i":{"docs":{},"l":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.011746987951807229},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.018072289156626505},"Injection.html":{"ref":"Injection.html","tf":0.03323262839879154},"Job.html":{"ref":"Job.html","tf":0.012605042016806723},"Cats.html":{"ref":"Cats.html","tf":0.015706806282722512},"TypedML.html":{"ref":"TypedML.html","tf":0.023622047244094488}},"u":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.002108433734939759},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"Cats.html":{"ref":"Cats.html","tf":0.006544502617801047},"TypedML.html":{"ref":"TypedML.html","tf":0.006299212598425197},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},"e":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"s":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"#":{"1":{"5":{"8":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"docs":{}},"docs":{}},"7":{"4":{"docs":{},"l":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"docs":{}},"docs":{}},",":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}},"i":{"docs":{},"d":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}}},"r":{"docs":{},"i":{"docs":{},"a":{"docs":{},"b":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}},"o":{"docs":{},"u":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"n":{"docs":{},"i":{"docs":{},"l":{"docs":{},"l":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}},"e":{"docs":{},"r":{"docs":{},"i":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"f":{"docs":{},"i":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"s":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{"./":{"ref":"./","tf":0.01598173515981735},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},"s":{"docs":{},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}}}}}},"b":{"docs":{},"o":{"docs":{},"s":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}}}},"c":{"docs":{},"t":{"docs":{},"o":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.006299212598425197}},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.009448818897637795}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"a":{"docs":{},"s":{"docs":{},"s":{"docs":{},"e":{"docs":{},"m":{"docs":{},"b":{"docs":{},"l":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"e":{"docs":{},"r":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},".":{"docs":{},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"n":{"docs":{},"s":{"docs":{},"f":{"docs":{},"o":{"docs":{},"r":{"docs":{},"m":{"docs":{},"(":{"docs":{},"t":{"docs":{},"e":{"docs":{},"s":{"docs":{},"t":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},")":{"docs":{},".":{"docs":{},"a":{"docs":{},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}},"d":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}},"s":{"docs":{},".":{"docs":{},"d":{"docs":{},"e":{"docs":{},"n":{"docs":{},"s":{"docs":{},"e":{"docs":{},"(":{"1":{"docs":{},",":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}}}}}}}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"i":{"docs":{},"e":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"a":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}},"s":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"w":{"docs":{},"a":{"docs":{},"n":{"docs":{},"t":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0030120481927710845},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedML.html":{"ref":"TypedML.html","tf":0.0031496062992125984}}}},"y":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.005545286506469501}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"r":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764},"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},".":{"docs":{"./":{"ref":"./","tf":0.00228310502283105},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"h":{"docs":{},"y":{"docs":{},"?":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}}},"e":{"docs":{},"n":{"docs":{},"(":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"s":{"2":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}},"docs":{}}}}}}}}}}}},"/":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"w":{"docs":{},"i":{"docs":{},"s":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"e":{"docs":{},"v":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},",":{"docs":{"./":{"ref":"./","tf":0.00228310502283105}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"i":{"docs":{},"n":{"docs":{},"f":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"m":{"docs":{},"a":{"docs":{},"n":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"_":{"1":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"2":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{}}}}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"h":{"docs":{},"o":{"docs":{},"w":{"docs":{},"(":{"docs":{},")":{"docs":{},".":{"docs":{},"r":{"docs":{},"u":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"[":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},"]":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"t":{"docs":{},"(":{"docs":{},"l":{"docs":{},"i":{"docs":{},"s":{"docs":{},"t":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"a":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"b":{"docs":{},"\"":{"docs":{},",":{"docs":{},"\"":{"docs":{},"c":{"docs":{},"\"":{"docs":{},")":{"docs":{},")":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"docs":{},"d":{"docs":{},"(":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"r":{"docs":{},"i":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"i":{"docs":{},"d":{"docs":{},"(":{"docs":{},"\"":{"docs":{},"s":{"docs":{},"a":{"docs":{},"m":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"j":{"docs":{},"o":{"docs":{},"b":{"docs":{},"\"":{"docs":{},")":{"docs":{},".":{"docs":{"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}}}}}}}}}}}}}}}}}}}}},"n":{"docs":{},"d":{"docs":{},"o":{"docs":{},"w":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}},"o":{"docs":{},"r":{"docs":{},"k":{"docs":{"./":{"ref":"./","tf":0.00684931506849315},"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004216867469879518},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}},"e":{"docs":{},"d":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},",":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}},"l":{"docs":{},"d":{"docs":{},"\"":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"n":{"docs":{},"'":{"docs":{},"t":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}},"]":{"docs":{},"(":{"docs":{},"o":{"docs":{},"t":{"docs":{},"h":{"docs":{},"e":{"docs":{},"r":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"(":{"2":{"9":{"6":{"2":{"5":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{},"(":{"docs":{},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"3":{"2":{"5":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"s":{"docs":{},"(":{"docs":{},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"2":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}}},"docs":{}}}}}}}}}}}}}}}},"s":{"docs":{},"a":{"docs":{},"n":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}},"i":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}},"(":{"docs":{},"s":{"docs":{},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}},"?":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"(":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}},"r":{"docs":{},"f":{"docs":{},"i":{"docs":{},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"s":{"docs":{},"(":{"docs":{},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"o":{"docs":{},"f":{"docs":{},"w":{"docs":{},"r":{"docs":{},"o":{"docs":{},"n":{"docs":{},"g":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}},"t":{"docs":{},"r":{"docs":{},"a":{"docs":{},"i":{"docs":{},"n":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"}":{"docs":{},")":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"w":{"docs":{},",":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},"[":{"docs":{},"i":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"$":{"docs":{},"\"":{"docs":{},"*":{"docs":{},"\"":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}},"i":{"docs":{},"\"":{"docs":{},"*":{"2":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}}}}},"l":{"docs":{},"i":{"docs":{},"n":{"docs":{},"e":{"1":{"4":{"docs":{},".":{"docs":{},"$":{"docs":{},"r":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"$":{"docs":{},"i":{"docs":{},"w":{"docs":{},"$":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"docs":{}},"docs":{}}}}},"a":{"docs":{},"n":{"docs":{},"o":{"docs":{},"n":{"docs":{},"$":{"1":{"docs":{},"@":{"1":{"7":{"5":{"5":{"9":{"0":{"3":{"1":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}}}}}},"'":{"docs":{},"`":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"i":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}},"x":{"docs":{},"`":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"n":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"'":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"p":{"docs":{},"o":{"docs":{},"p":{"docs":{},"u":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},"n":{"docs":{},")":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"r":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},")":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"o":{"docs":{},"j":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}},"(":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"`":{"docs":{},"i":{"docs":{},"`":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},")":{"docs":{},".":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"(":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}},"_":{"4":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}},"q":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}},"x":{"docs":{},"'":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"z":{"docs":{},"'":{"docs":{},")":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}},"*":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0036144578313253013},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}},"(":{"1":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0084530853761623}}}},"docs":{}}},".":{"docs":{},".":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0051204819277108436},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845},"TypedML.html":{"ref":"TypedML.html","tf":0.014173228346456693}},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"a":{"docs":{},"c":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"p":{"docs":{},"p":{"docs":{},"l":{"docs":{},"i":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}},"s":{"docs":{},"[":{"docs":{},"h":{"docs":{},"o":{"docs":{},"u":{"docs":{},"s":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"w":{"docs":{},"i":{"docs":{},"t":{"docs":{},"h":{"docs":{},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"s":{"docs":{},"e":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"f":{"docs":{},"l":{"docs":{},"a":{"docs":{},"t":{"docs":{},"t":{"docs":{},"e":{"docs":{},"n":{"docs":{},"o":{"docs":{},"p":{"docs":{},"t":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"i":{"docs":{},"l":{"docs":{},"t":{"docs":{},"e":{"docs":{},"r":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"s":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"c":{"docs":{},"t":{"docs":{},"(":{"docs":{},"$":{"docs":{},"\"":{"docs":{},"*":{"docs":{},"\"":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"'":{"docs":{},"_":{"2":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}},"docs":{}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}},"o":{"docs":{},"r":{"docs":{},"t":{"docs":{},"d":{"docs":{},"e":{"docs":{},"s":{"docs":{},"c":{"docs":{},"(":{"docs":{},"'":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}},"g":{"docs":{},"r":{"docs":{},"o":{"docs":{},"u":{"docs":{},"p":{"docs":{},"b":{"docs":{},"y":{"docs":{},"(":{"docs":{},"'":{"docs":{},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},")":{"docs":{},".":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"(":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"h":{"docs":{},"e":{"docs":{},"a":{"docs":{},"d":{"docs":{},".":{"docs":{},"_":{"1":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}},"docs":{}}}}}}},"i":{"docs":{},"n":{"docs":{},"n":{"docs":{},"e":{"docs":{},"r":{"docs":{},"j":{"docs":{},"o":{"docs":{},"i":{"docs":{},"n":{"docs":{},"(":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"m":{"docs":{},"a":{"docs":{},"p":{"docs":{},"t":{"docs":{},"f":{"docs":{},")":{"docs":{},".":{"docs":{},"u":{"docs":{},"s":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"(":{"docs":{},"'":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},":":{"2":{"0":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"3":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"4":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"5":{"docs":{},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}},"7":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}},"8":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"9":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253}}}},"docs":{}},"3":{"0":{"docs":{},":":{"docs":{"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}}},"1":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"5":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846},"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},"6":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}},"7":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.003937007874015748}}}},"9":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}},"4":{"0":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"3":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"5":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"6":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}},"9":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419}}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869},"Cats.html":{"ref":"Cats.html","tf":0.02356020942408377}}},")":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"d":{"docs":{},"a":{"docs":{},"t":{"docs":{},"a":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"[":{"docs":{},"(":{"docs":{},"a":{"docs":{},"d":{"docs":{},"d":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},",":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}},"f":{"docs":{},"a":{"docs":{},"m":{"docs":{},"i":{"docs":{},"l":{"docs":{},"y":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}},"n":{"docs":{},"e":{"docs":{},"i":{"docs":{},"g":{"docs":{},"h":{"docs":{},"b":{"docs":{},"o":{"docs":{},"r":{"docs":{},"h":{"docs":{},"o":{"docs":{},"o":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"u":{"docs":{},"n":{"docs":{},"t":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}}}}}}}}}}}}},"p":{"docs":{},"e":{"docs":{},"r":{"docs":{},"s":{"docs":{},"o":{"docs":{},"n":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0036968576709796672}}}}}}}}}},"t":{"docs":{},"u":{"docs":{},"p":{"docs":{},"l":{"docs":{},"e":{"1":{"docs":{},"[":{"docs":{},"s":{"docs":{},"t":{"docs":{},"r":{"docs":{},"i":{"docs":{},"n":{"docs":{},"g":{"docs":{},"]":{"docs":{},"]":{"docs":{},")":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}}}}}}},"docs":{}}}}}}}}}}}}}}}}}}}}}},"[":{"1":{"docs":{},".":{"0":{"docs":{},",":{"2":{"docs":{},".":{"0":{"docs":{},",":{"3":{"docs":{},".":{"0":{"docs":{},"]":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{}}},"docs":{},".":{"docs":{},".":{"1":{"0":{"docs":{},"]":{"docs":{},")":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}},"docs":{}},"docs":{}}}}},"docs":{},"'":{"docs":{},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"i":{"docs":{},"]":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"x":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"_":{"1":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0036144578313253013},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}}},"docs":{}},"b":{"docs":{},"e":{"docs":{},"d":{"docs":{},"r":{"docs":{},"o":{"docs":{},"o":{"docs":{},"m":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"#":{"1":{"3":{"8":{"4":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004819277108433735}}}}}}},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"]":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"a":{"docs":{},"g":{"docs":{},"g":{"docs":{},"r":{"docs":{},"e":{"docs":{},"g":{"docs":{},"a":{"docs":{},"t":{"docs":{},"e":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"o":{"docs":{},"u":{"docs":{},"t":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"r":{"docs":{},"a":{"docs":{},"t":{"docs":{},"i":{"docs":{},"o":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"t":{"docs":{},"t":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0009036144578313253},"Job.html":{"ref":"Job.html","tf":0.004201680672268907}}}}}}}},"]":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00422654268808115}}}},"a":{"docs":{},"]":{"docs":{},"f":{"docs":{},"r":{"docs":{},"a":{"docs":{},"m":{"docs":{},"e":{"docs":{},"l":{"docs":{},"e":{"docs":{},"s":{"docs":{},"s":{"docs":{},".":{"docs":{},"t":{"docs":{},"y":{"docs":{},"p":{"docs":{},"e":{"docs":{},"d":{"docs":{},"c":{"docs":{},"o":{"docs":{},"l":{"docs":{},"u":{"docs":{},"m":{"docs":{},"n":{"docs":{},"[":{"docs":{},"f":{"docs":{},"o":{"docs":{},"o":{"docs":{},",":{"docs":{},"a":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}},"g":{"docs":{},"e":{"docs":{},":":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553}}}}}},"i":{"docs":{},"#":{"2":{"3":{"docs":{},"l":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},",":{"docs":{},"j":{"docs":{},"#":{"2":{"4":{"docs":{},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"docs":{}}}},"]":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}},"docs":{}},"docs":{}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0033812341504649195},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.0030120481927710845}}},"n":{"docs":{},"p":{"docs":{},"u":{"docs":{},"t":{"docs":{},"[":{"0":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}}}}}},"s":{"docs":{},"n":{"docs":{},"o":{"docs":{},"t":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"2":{"3":{"docs":{},"l":{"docs":{},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}},"docs":{}},"docs":{}},")":{"docs":{},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0016906170752324597}}}}}}}}}}}}}}},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"i":{"docs":{},"#":{"2":{"3":{"docs":{},"l":{"docs":{},")":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}},"docs":{}},"docs":{}}}}}},"q":{"docs":{},"u":{"docs":{},"a":{"docs":{},"r":{"docs":{},"e":{"docs":{},"f":{"docs":{},"e":{"docs":{},"e":{"docs":{},"t":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.010236220472440945}}}}}}}}}}}}},"f":{"docs":{},"e":{"docs":{},"a":{"docs":{},"t":{"docs":{},"u":{"docs":{},"r":{"docs":{},"e":{"docs":{},"s":{"docs":{},":":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.002362204724409449}}}}}}}}}}}},"^":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.004216867469879518},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00507185122569738},"TypedEncoder.html":{"ref":"TypedEncoder.html","tf":0.006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.00906344410876133},"TypedML.html":{"ref":"TypedML.html","tf":0.005511811023622047}}},"_":{"1":{"docs":{},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00391566265060241}}}},"2":{"docs":{},":":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0036144578313253013},"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095},"TypedML.html":{"ref":"TypedML.html","tf":0.0015748031496062992}}},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00391566265060241}}}},"3":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}},"4":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{}},"x":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}},".":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}},":":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"{":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.015105740181268883},"Job.html":{"ref":"Job.html","tf":0.004201680672268907},"Cats.html":{"ref":"Cats.html","tf":0.002617801047120419},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}},"|":{"1":{"0":{"0":{"0":{"docs":{},"|":{"1":{"0":{"2":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}}},"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}},"docs":{}},"2":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"2":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"7":{"6":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"6":{"2":{"docs":{},".":{"8":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"6":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}}},"docs":{}},"docs":{}},"9":{"0":{"8":{"3":{"3":{"3":{"docs":{},".":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"3":{"docs":{},"|":{"1":{"2":{"docs":{},".":{"5":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"6":{"8":{"docs":{},"|":{"docs":{},"h":{"docs":{},"e":{"docs":{},"l":{"docs":{},"l":{"docs":{},"o":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.01566265060240964},"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.006762468300929839}},"c":{"docs":{},"i":{"docs":{},"t":{"docs":{},"y":{"docs":{},"|":{"docs":{},"s":{"docs":{},"u":{"docs":{},"r":{"docs":{},"f":{"docs":{},"a":{"docs":{},"c":{"docs":{},"e":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}}}}}}}}}},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}}}}},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"|":{"docs":{},"n":{"docs":{},"u":{"docs":{},"l":{"docs":{},"l":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},"|":{"2":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"3":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"4":{"5":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0015060240963855422}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"5":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"6":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{}}},"docs":{}},"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"9":{"0":{"0":{"0":{"0":{"0":{"docs":{},".":{"0":{"docs":{},"|":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}},"docs":{}}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{}},"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0030120481927710845}},"[":{"docs":{},"a":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}},"b":{"docs":{},"c":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}}}}}}}},"{":{"docs":{},"l":{"docs":{},"y":{"docs":{},"o":{"docs":{},"n":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169}}}}}}},"n":{"docs":{},"i":{"docs":{},"c":{"docs":{},"e":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.00030120481927710846}}}}}}},"p":{"docs":{},"a":{"docs":{},"r":{"docs":{},"i":{"docs":{},"s":{"docs":{},",":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0012048192771084338}}}}}}}}},"v":{"docs":{},"a":{"docs":{},"l":{"docs":{},"u":{"docs":{},"e":{"docs":{},"|":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.00253592561284869}}}}}}}},"+":{"docs":{},"|":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.003926701570680628}}}}},"}":{"docs":{"FeatureOverview.html":{"ref":"FeatureOverview.html","tf":0.0006024096385542169},"Injection.html":{"ref":"Injection.html","tf":0.006042296072507553},"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0073937153419593345}},")":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}},",":{"docs":{"Injection.html":{"ref":"Injection.html","tf":0.0030211480362537764}}}},",":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}},"`":{"docs":{},"s":{"docs":{},"u":{"docs":{},"m":{"docs":{},"(":{"docs":{},"i":{"docs":{},")":{"docs":{},"`":{"docs":{},")":{"docs":{},"'":{"docs":{"TypedDatasetVsSparkDataset.html":{"ref":"TypedDatasetVsSparkDataset.html","tf":0.0008453085376162299}}}}}}}}}}},"l":{"docs":{},"a":{"docs":{},"b":{"docs":{},"e":{"docs":{},"l":{"docs":{},"s":{"docs":{},"`":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}},"a":{"docs":{},"r":{"docs":{},"r":{"docs":{},"a":{"docs":{},"y":{"docs":{},"`":{"docs":{"TypedML.html":{"ref":"TypedML.html","tf":0.0007874015748031496}}}}}}}}}}}}}}},"y":{"docs":{},"e":{"docs":{},"t":{"docs":{},".":{"docs":{"Cats.html":{"ref":"Cats.html","tf":0.0013089005235602095}}}}}},"?":{"docs":{},"?":{"docs":{},"?":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}},"z":{"docs":{},"e":{"docs":{},"r":{"docs":{},"o":{"docs":{},".":{"docs":{"TypedDataFrame.html":{"ref":"TypedDataFrame.html","tf":0.0018484288354898336}}}}}}}},"length":3641},"corpusTokens":["\"\",","\"0.9.0\"","\"_1\".","\"a","\"abc\")","\"another\")))","\"daterange\"","\"dummy\"","\"e\")","\"false\")","\"frameless","\"java.util.date\",","\"jday\")","\"lyon\",","\"mydate\"","\"org.typelevel\"","\"paris\")","\"paris\",","\"q\")","\"s\")","\"s\"))))","\"s\",","\"san","\"string\"),","\"task2\"","\"unique\"","\"value\"","\"w\")","$\"*\".","$\"i\"*2)","$anon$1@17559031","$line14.$read$$iw$$iw$$iw$$iw$foo","$line14.$read$$iw$$iw$$iw$$iw$foo),","%","%%","'(sum(`i`)","').map(r","'_4)","'`citi`'","'`i`'","'`x`'","'city),","'name),","'null'","'population)","'price),","'project","'q',","'s)","'x',","'z'))","'z'.","(\"anna\",","(\"bob\",","(\"chris\",","(\"joe\",","(\"john\",","(\"sam\",","(((((((((","(0","(0,0,0)","(1,","(1,2,3)","(10,9,9)","(2,","(8,","(8,2,3)","(a","(and","(apttypedds)","(apttypedds2)","(case","(chris,map(0","(class:","(column:","(e.g.","(e.g.,","(empti","(enjoy","(frameless.typedcolumn[(string,","(frameless.typedcolumn[apartment,int])","(frameless.typedcolumn[apartment,string],","(from","(i","(i#23l","(i.e.,","(if","(implicit","(in","(includ","(int)","(int,","(isnotnull(i#23l)","(john,map(0","(look","(lyon,166500.0))","(name","(name:","(or","(paris,333333.3333333333),","(peopl","(phonebooktf:","(repres","(sam,map(0","(sample:","(see","(semigroup)","(seq[(int,","(short","(sinc","(string,","(such","(the","(thumb","(u:","(up","(what","(which","(with","(wrappedarray((1,string)),2)",")","))",").as[apartmentdetails]",").as[aptpricecity].show().run",").as[stats].show().run()",").show().run()",").show(1).run()",").show(2).run()","*","*(1)","+","++=","+1,",",","...","...).",".ac",".appli",".as[family]()",".as[housedatawithfeatures]",".as[neighborhoodcount]()",".dataset",".desc.",".filter",".flatmap",".flattenopt",".groupby('neighborhood).count()",".head._1",".innerjoin(citymaptf).using('address)",".select($\"*\",",".select('_2,",".select('neighborhood)",".sortdesc('count)","/","//","0","0)))","0.0|","0.0|325000.0|","0.13.13:","0.2,","0.4","0.4.0","0.4.1","0.5.2","0.5.x","0.6.1","0.6.x","0.7.0","0.8","0.8.0","0.9","0.9.0","0.9.x","1","1)","1))","1)),","1),","1,","1.0","1.0.0","1.1|","1.6","1.6+,","1.6,","1.x","10","10))","10),","10).map(_.i).explain()","10).map(_.i).show()","10).map(_.x).show()","10).select($\"i\".as[long])","10).select($\"x\".as[long])","10).select(fds('i)).explain()","10).select(fds('i)).show().run()","10).select(fds('x))","10)],","10,","100)","100,","10000.0,","100000)))","100000),","102|","10|","11","11))","12)","12,","133000...|","133000.0,","133000.0|","133|","15)))","19","1:","1|","1|250000.0|","2","2)","2)#165l]","2))","2)),","2)).","2)).show().run()","2),","2).as[updatedsurface]","2).show().run()","2).show(2).run()","2,","2.0","2.0)","2.0,","2.10,","2.11","2.11,","2.11/2.12","2.12","2.12.x.","2.2.0","2.2.1","2.3.0","2.3.0.","2.3.1","2.3.2.","2.4.0","20","20%","20)","20,","200000),","200000...|","200000.0,","200000.0|","2021))","20:29:11","22.","2229621),","2229621|","2229621}|","2409.6385542168673,","25,","25000...|{paris,","250000),","250000.0,","250000.0|","250|","25|[paris,","27|","2955.5555555555557,","2:","2|","2|300000.0|","2|[a,","2}|[a,","3","3)","3))","3),","3,","3.0.0","3.0.0):","3.1.0.","30000...|{paris,","300000.0,","300000.0|","32,","325000...|","325000.0,","325000.0|","343629)","343629|","343629}|","3|","3|450000.0|","3|[a,","4","4))","4)),","4,","42","4391.891891891892)","4391.891891891892|","45,","4500...|{paris,","4500.0,","450000.0,","450000.0|","450|","45|133000.0|","47|","4|","5,","50,","500000)","500000),","500715),","500715|","500715}|","500|","50|300000.0|","52|","6,","6833.333333333333|","74,","740|","76|","800000)))","83,","830|","83|200000.0|","85|","9000.0|","900000)",":",":)",":20:",":23:",":24:",":25:",":26:",":27:",":28:",":29:",":30:",":31:",":35:",":36:",":37:",":39:",":40:",":43",":45",":46",":49","::",":typeddataframe[(address,",":typeddataframe[(string,",":typeddataframe[family])",":typeddataframe[neighborhoodcount])",":typeddataframe[person])",":typeddataframe[tuple1[string]])","=","==","===","=>",">",">=","???","['citi]","['x]","[1...10]).","[1.0,2.0,3.0]","[],","[_1:","[a]frameless.typedcolumn[foo,a]","[age:","[bedrooms,","[city#1384,","[city:","[features:","[i#23l","[i#23l,j#24]","[i#23l]","[i,","[i:","[input[0,","[isnotnull(i#23l),","[isnotnull(i),","[out,","[out]frameless.typedaggregate[foo,out]","[ratio:","[squarefeet:","[sum(i#23l)","[tt,","[value:","^","_1.","_1|","_2:","_2|","_3|","_4|","`labels`","`labelsarray`","`sum(i)`)'","a)(implicit","a):","a,","ab","abil","abov","above)","above,","above.","abstract","accept","access","accident","achiev","act","action","action[(seq[(int,","action[t]","actual","ad","adapt","add","added,","addit","addition,","address","address,","address:","adelbertc","adjust","adjustedpric","adjustedprice.show().run()","adjustedprice:","advanc","aforement","again","against","agg()","agg(avg(aptds('price))).","aggreg","aggregated,","agree.","algebra","alia","alias","align","align.","allcities:","allcities|","alldata.csumbykey","alldata:","alldatacomplexkeu","alldatacomplexkeu.csumbykey","alldatacomplexkeu:","allow","allowed,","allowed:","along","alphabet:","alternatively,","alternatives:","amount","and/or","anna","annotate/nam","annoy","anoth","another,","anyth","apach","apart","apartment'","apartment(\"lyon\",","apartment(\"nice\",","apartment(\"paris\",","apartment(city:","apartment.","apartmentdetail","apartmentdetails(city:","apartmentdetails?","apartmentopt(city:","apartmentopt(none,","apartmentopt(some(\"paris\"),","apartmentshortinfo","apartmentshortinfo(city:","apartmentshortinfo?","apartmentsopt","api","api,","api.","apis),","appear","append","appli","applic","applications.","apply(a:","apply(d:","approach","approach,","approxim","aptd","aptds('city),","aptds('price)","aptds('price)))","aptds('price),","aptds('surface),","aptds('surface).cast[double]","aptds('surface).cast[double])","aptds.","aptds.agg(","aptds.select(","aptds.select('citi)","aptds.select(aptds('city),","aptds.typ","aptds:","aptprice:","aptpricec","aptpricecity(city:","apttypedd","apttypedds('city)","apttypedds('city)).as[updatedsurface]","apttypedds('city).asc,","apttypedds('city).cast[double]","apttypedds('price).desc","apttypedds('surface)","apttypedds('surface))","apttypedds('surface).cast[double])","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('city)))","apttypedds.groupby(apttypedds('city)).agg(avg(apttypedds('price)))","apttypedds.joininner(citiinfotypedds)","apttypedds.makeudf(pricemodifier)","apttypedds.orderby(","apttypedds.orderby(apttypedds('city).asc).show(2).run()","apttypedds.project[apartmentshortinfo]","apttypedds.select(apttypedds('citi))","apttypedds.select(apttypedds('city))","apttypedds.select(apttypedds('city),","apttypedds.select(apttypedds('price)","apttypedds.select(apttypedds('surface)","apttypedds.union(apttypedds2).show().run","apttypedds2","apttypedds2('price)","apttypedds2('price)).","apttypedds2.drop[citybeds]","apttypedds2.droptupled('price):","apttypedds2.union(apttypedds).show().run","apttypedds2.withcolumnreplaced('price,","apttypedds2.withcolumntupled(","apttypedds2.withcolumntupled(lit(array(\"a\",\"b\",\"c\"))).show(2).run()","apttypedds2:","apttypedds:","apttypeddsopt","apttypeddsopt('surface)","apttypeddsopt('surface).opt.map(_","apttypeddsopt.select(apttypeddsopt('surface)","apttypeddsopt.select(apttypeddsopt('surface).opt.map(c","apttypeddsopt.show().run()","apttypeddsopt:","aptwithratio","aptwithratio.project[cityinfo]","aptwithratio.project[priceinfo2]","aptwithratio.project[priceinfo3]","aptwithratio.project[priceinfo]","aptwithratio:","arbitrari","are:","area","argument","arguments)","arithmet","ariti","arity.","around","array","array((joe,map(0","array(1,","array[(username,","array]","arraycontains(t('_1),","arraycontains(t('_2),","arraycontains:","as:","as[bedroomstats]","as[long]","as[t]","ascol","ascol()","assembl","assembler.transform(testdata).as[housedatawithfeatures]","assembler.transform(trainingdata)","assembler.transform(trainingdata).as[housedatawithfeatures]","assembler.transform(trainingdata).as[wronghousefeatures]","assembler.transform(wrongtrainingdata)","assembler:","associ","assum","automat","avail","available,","available.","averag","averaging,","avg","avg(aptds('price))","avg(aptds('price)),","avg(aptds('surface))","avg(aptds('surface)),","avg,","avgprice:","avgpricebeds1:","avgpricebeds2:","avgpricebeds3:","avgpricebeds4:","avgprice|","avgsurface:","avgsurface|minsurface|","avoid","away:","b","b):","b,","b.","b:","b]","back","bar","bar(1)))","bar(1.1,","bar(d:","bar(i:","bar)","bar.","bardate(1.1,","bardate(d:","bardate)","base","batched:","be","becom","bedroom","bedrooms#1387]","bedrooms.","bedrooms:","bedroomstat","bedroomstats(","bedroomstats('avgpricebeds2).getorelse(0.0),","bedroomstats('avgpricebeds3).getorelse(0.0))","bedroomstats(lyon,some(133000.0),some(200000.0),none,none)","bedroomstats(nice,none,none,some(325000.0),none)","bedroomstats(paris,some(250000.0),some(300000.0),some(450000.0),none)","bedroomstats.collect().run().foreach(println)","bedroomstats.dataset.todf().filter($\"avgpricebeds2\".isnotnull)","bedroomstats.flattenoption('avgpricebeds2)","bedroomstats.select(","bedroomstats.show().run()","bedroomstats:","before.","behav","behavior","bellow:","below","below.","benefit","besid","best","bestneighborhood","better","between","bigint","bigint))","bigint,","bigint]","bind","birthday:","block","boolean","boolean)","boolean):","boolean)]","boolean)].","boolean,","boolean:","bootstrap","both","break","bring","bug","build.sbt","built","bulletproof:","bypass","c","c('_2)).show(2).run()","c,","c.","c.select(c.colmany('_1,","c.show(1).run()","c:","c]|","calcul","call","caller","calls,","can't","can't,","capabl","captur","care","case","case)","case,","cases.","cast","cast(10","cast(2","cast,","cat","catalyst","catalystcast.","catalystcast[string,","catch","categor","cats\"","cats.","cats.data.readert","cats.effect.implicits._","cats.effect.io","cats.effect.sync","cats.effect.sync[f].","cats.implicit","cats.implicits._","cats.mtl.implicits._","cats:","caught","caus","chang","change.","channel","check","choos","citi","citi:","cities:","citiinfotypedd","citiinfotypedds('name)","city,","city.","city:","cityb","citybeds(city:","citybeds(lyon,2))","citybeds(paris,1))","citybeds(paris,1),","citybeds(paris,3))","citybeds(paris,3),","citybeds.","citybeds.head(3).run()","citybeds.headoption.run()","citybeds.limit(4).collect().run()","citybeds.select(citybeds.ascol,","citybeds.take(2).run()","citybeds:","citybedsoth","citybedsother(city:","cityindexed:","cityinfo","cityinfo(city:","citymapentry(","citymaptf:","citypopulation:","citypopulationinfo(\"lyon\",","citypopulationinfo(\"nice\",","citypopulationinfo(\"paris\",","citypopulationinfo(name:","citypopulationinfo)]","citypopulationinfo)].","citypriceratio","citypriceratio.groupby(citypriceratio('_1)).agg(avg(citypriceratio('_2))).show().run()","citypriceratio:","cityratio","cityratio.select(cityratio('city),","cityratio.show(2).run()","cityratio:","city|","city|aptprice|citypopulation|","city|avgpricebeds1|avgpricebeds2|avgpricebeds3|avgpricebeds4|","city|bedrooms|","city|surface|","class","class:","classes)","classes.","claus","clause.","clearli","click","close","closur","closures.","cmax","cmin","code","code.","collect","collect())","collection,","collectset(aptds('city))","colmany()","column","column\")","column(s)","column(s).","column,","column.","column:","columnar","columnartorow","columns)","columns,","columns.","columns:","combin","come","common","commonli","companion","compar","comparison","comparison,","compat","compil","compile)","compile,","compile.","compile:","compiles:","complet","complex","compos","composit","comprehens","compromis","comput","computations.","computeminofsample(countandtakejob)","computeminofsample(sample:","computeminofsample:","concat,","concept:","condition","conduct","conf","confus","consid","consist","consol","construct","constructor","contain","content","context","continu","contrari","contribut","contributor","conveni","convention.","convert","correct","correct.","correctli","correspond","count","count,","count:","countandtakejob","counterpart","coupl","creat","csum,","current","custom","customizable,","d.gettime()","d:","d]|true|","data","data)","data,","data.","data:","datafilters:","datafram","dataframe'","dataframe,","dataframes,","dataset","dataset\"","dataset,","dataset.","dataset/datafram","dataset:","dataset?.","dataset[daterange]","dataset[long].","datasets,","datawithfeatur","datawithfeatures:","daterange(s:","datetolonginject","datetolonginjection:","day","day1","day1:","day2","day2:","dayscombin","dayscombined.collect()","dayscombined:","deal","decod","def","default","defin","definit","delay","depend","deprec","deriv","derived,","descript","description.","deserializetoobject","design","design,","detail","detail.","detect","develop","differ","different,","directli","discuss","discussion.","disk","distinguish","dive","divid","divided,","document","document.","domain","don't","done","doubl","double)","double)(implicit","double)]","double,","double:","double]","double])","driver","drop","drop().","drop/replace/add","droptupled()","ds","ds.collect()","ds.filter($\"i\"","ds.filter(_.i","ds.select(sum($\"i\"),","ds.show()","ds:","due","e.g.,","e:","each","earli","easi","easier","easili","effect","effect,","effect:","effects.","element","elements.","elements:","elid","empti","empty,","emptyrdd","emptyrdd[13]","encod","encoder,","encoder.","encoder:","encoder[bar]","encoders,","enhanc","enough","enrich","ensur","entir","environ","equalto(i,10)],","equival","equivelantli","error","error)","error.","error:","essenti","estimator.","estimators.","etc)","etc.","etc.).","everyth","evid","evidence$1:","exactli","exampl","example,","example.","example:","except","exclus","execut","exhaustive.","exist","expect","expected:","expens","explain","explan","explicit","explicitli","explode()","explode(_2)","explode(_2),","expos","express","expression'","expressionencod","extend","extra","extrem","e|","f","f.neighborhood))","f.residents.split('","f[_]","f[_],","f[a]","f[a],","fact","fail","failure:","false,","false]","familiar","family(residents:","family:","faster","fd","fds('i)).show().run()","fds.agg(fsum(fds('i))+22).show().run()","fds.agg(fsum(fds('i)),","fds.filter(fds('i)","fds.select(fsum(fds('i)))","fds:","featur","features(price:","features(squarefeet:","features).","features):","features.","features:","feed","feel","femal","female,","few","field","field]","fields.","fields]","file","file.","filescan","filter","filter(conditionexpr:","filteredd","filteredds.explain()","filteredds.show()","filteredds:","finaljob","finaljob.","finaljob:","finally,","find","first","first()","first,","first_value)","fit","five","flat","flatten","flattened.show(4).run()","flattened:","flattenstat","flattenstats:","focu","follow","follows:","foo","foo'","foo(1,","foo(10,","foo(100,","foo(i:","foo(s:","foo,","foo.","foodate(i:","footag","footage.","forest,","form","formal","format","format:","found","frameless","frameless'","frameless,","frameless.","frameless._","frameless.abstracttypedcolumn[?t,?c[?a]]","frameless.abstracttypedcolumn[t,c[a]]","frameless.abstracttypedcolumn[t,c[a]],","frameless.catalystcast[string,double]","frameless.catalystcollection[c])column.thistype[t,boolean]","frameless.catalystdivisible[double,out],","frameless.catalystnumeric[double])frameless.typedcolumn[apartment,double]","frameless.catalystnumeric[option[int]])frameless.typedcolumn[apartmentopt,option[int]]","frameless.catalystnumeric[option[int]],","frameless.cats.implicits.","frameless.cats.implicits._","frameless.cats.implicits._.","frameless.cats.outer._","frameless.functions._","frameless.functions.aggregate._","frameless.functions.aggregate.{sum","frameless.functions.aggregate.{sum=>fsum}","frameless.functions.lit","frameless.functions.nonaggregate._","frameless.functions.nonaggregate.when","frameless.functions.udf$$lambda$12549/0x0000000803898840@61521397","frameless.injection$$anon$1@7c0fbe02","frameless.injection$$anon$1@7d716477","frameless.injection[gender,int]","frameless.injection[java.util.date,long]","frameless.job","frameless.job$$anon$2@123416f3","frameless.job$$anon$4@77bca0d3","frameless.job[int]","frameless.job[seq[foo]]","frameless.job[seq[int]])frameless.job[int]","frameless.ml._","frameless.ml.appendtransformer[rfinputs,frameless.ml.classification.typedrandomforestclassifier.outputs,org.apache.spark.ml.classification.randomforestclassificationmodel]","frameless.ml.appendtransformer[rfinputs,frameless.ml.regression.typedrandomforestregressor.outputs,org.apache.spark.ml.regression.randomforestregressionmodel]","frameless.ml.appendtransformer[stringindexerinput,frameless.ml.feature.typedstringindexer.outputs,org.apache.spark.ml.feature.stringindexermodel]","frameless.ml.classification._","frameless.ml.classification.typedrandomforestclassifier@33ab9b32","frameless.ml.classification.typedrandomforestclassifier[rfinputs]","frameless.ml.feature._","frameless.ml.feature.typedindextostring@355dd92d","frameless.ml.feature.typedindextostring[indextostringinput]","frameless.ml.feature.typedstringindexer@4c2621e0","frameless.ml.feature.typedstringindexer[stringindexerinput]","frameless.ml.feature.typedvectorassembler@a559710","frameless.ml.feature.typedvectorassembler@eb06753","frameless.ml.feature.typedvectorassembler[features]","frameless.ml.regression._","frameless.ml.regression.typedrandomforestregressor@37d61f51","frameless.ml.regression.typedrandomforestregressor[rfinputs]","frameless.ml.typedestimator$$anon$1@5bd75b8","frameless.ml.typedestimator$$anon$1@5d5c3","frameless.ml.typedestimator$$anon$1@6145e82d","frameless.ops.as[(double,","frameless.ops.as[(string,","frameless.syntax._","frameless.typedaggregate[foo,?]","frameless.typedcolumn[(string,","frameless.typedcolumn[apartment,double]","frameless.typedcolumn[apartment,double])","frameless.typedcolumn[foo,?]","frameless.typedcolumn[tt,double])(implicit","frameless.typedcolumn[tt,option[int]])(implicit","frameless.typeddatafram","frameless.typeddataset","frameless.typeddataset[(apartment,","frameless.typeddataset[(citybeds,","frameless.typeddataset[(double,","frameless.typeddataset[(int,","frameless.typeddataset[(string,","frameless.typeddataset[apartment]","frameless.typeddataset[apartmentdetails]","frameless.typeddataset[apartmentopt]","frameless.typeddataset[apartmentshortinfo]","frameless.typeddataset[bedroomstats]","frameless.typeddataset[citybeds]","frameless.typeddataset[cityinfo]","frameless.typeddataset[double]","frameless.typeddataset[foo]","frameless.typeddataset[housecityprediction]","frameless.typeddataset[housecitypredictionindexed]","frameless.typeddataset[housecitypredictioninputs]","frameless.typeddataset[housedata]","frameless.typeddataset[housedatawithfeatures]","frameless.typeddataset[housedatawithfeaturesandindex]","frameless.typeddataset[housepriceprediction]","frameless.typeddataset[int]","frameless.typeddataset[person]","frameless.typeddataset[priceinfo]","frameless.typeddataset[string]","frameless.typeddataset[this.out]","frameless.typeddataset[updatedsurface]","frameless.typeddataset[wronghousedata]","frameless.typedencoder[daterange]","frameless.typedencoder[foodate]","frameless.typedencoder[mydate]","frameless.typedencoder[out],","frameless.typedencoder[person]","frameless.with[apartment,tt]{typ","frameless.with[apartmentopt,tt]{typ","frameless:","frameless_gen_min_s","frameless_gen_size_rang","framelessvers","framelessversion,","francisco\",","francisco)","free","friend.","friendli","from)","fsum}","full","fulli","function","function(s)","function.","function:","functions.","functions:","further","futur","g8","garden","gender","gender)","gender:","gendertoint:","gener","general).","generated.","get","get.;","getorelse().","giter8","github,","gitter","gitter)","give","given","go","goal","goal:","goe","great!","ground,","group","groupbi","groupby()","groupby(aptds('city)).","guard","hand","handhold","handl","harder","hasgarden","hasgarden:","have","help","help?","here","here.","here:","hierarchi","hold","hood,","hous","housecitypredict","housecityprediction(","housecitypredictionindex","housecitypredictionindexed(","housecitypredictioninput","housecitypredictioninputs(features:","housedata","housedata(100,","housedata(150,","housedata(20,","housedata(200,","housedata(50,","housedata(squarefeet:","housedata?","housedatawithfeatur","housedatawithfeatures(squarefeet:","housedatawithfeaturesandindex","housedatawithfeaturesandindex(","housepricepredict","housepriceprediction(","however,","http://opensource.org/licenses/apach","i.","i:","id","ident","if(nam","ignor","imario","imarios/frameless.g8","imperfections,","implement","implicit","implicitli","implicits.scala:42","implicits.scala:67","import","improv","inabl","includ","incompat","index","indexeddata","indexeddata:","indexedpredict","indexedpredictions:","indexedtestdata","indexedtestdata.project[housecitypredictioninputs]","indexedtestdata:","indexer.estimator.sethandleinvalid(\"keep\")","indexer.estimator.typ","indexer.fit(datawithfeatures).run()","indexer:","indexermodel","indexermodel.transform(datawithfeatures).as[housedatawithfeaturesandindex]","indexermodel.transform(testdatawithfeatures).as[housedatawithfeaturesandindex]","indexermodel:","indextostr","indextostring.transform(indexedpredictions).as[housecityprediction]","indextostring:","indextostringinput","indextostringinput(predictedcityindexed:","inflat","inflation.show(2).run()","inflation:","inform","initi","initiald","initialds.write.parquet(\"/tmp/foo\")","initialds:","inject","injection(","injection((_:","injection.appli","injection:","injection[a,","injection[gender,","injection[java.util.date,","inmemoryfileindex[file:/tmp/foo],","input","inputs:","insid","instal","instanc","instance,","instance.","instances:","instanti","instead","instead.","int","int)","int).","int)]","int,","int.","int]","integr","intention","interest","intermedi","intern","introduc","introduct","intuitively,","invalid","invert(b:","invert(l:","io","issue,","issue:","issues.","issues/questions.","it'","it.","i|","j.","j:","j];","jan","jar.","java.lang.unsupportedoperationexception:","java.util.d","java.util.date((_:","java.util.date(l)","java.util.date(system.currenttimemillis))))","java.util.date)","java.util.date))","java.util.date)))","java.util.date))))","java.util.date)).tods()","java.util.date).gettime(),","java.util.date):","java.util.date,","java.util.date.","job","job,","job[a]","job[int]","job[seq[int]]):","jobs.","joe","join","join1(tf1:","join2(tf1:","joins,","jvm","j|","kanterov","keep","kernel","key","key.","keys.","know","known","label","label)","label):","label,","languag","larg","last","later","layer","lazi","lazili","lazy,","lazy.","lead","learning.","less","let","let'","letter","level","leverag","librari","library:","librarydepend","licens","lift","like,","limit","limitations.","line","linux","list","list(","list(person(42,male))","list(person(42,tu","list[int])]","list[string])","list[string]),string]","list[string]),string],","list[string])]","lit(0.001))","lit(1.1)).","lit(list(\"a\",\"b\",\"c\")))","lit(list(\"abc\",\"c\",\"d\")))","lit(list(1,2,3,4)))","litaggr(\"hello","liter","load","local","localrel","locat","location:","long","long)","long)))","long):","long)]","long)])","long,","long:","long]","look","lose","lowest","lyon]|","lyon|","lyon|133000.0|","lyon|200000.0|","lyon|2682.5970548862115|","mac","machineri","macro","made","main","maintain","make","makerdd","male","male))","male,","manag","mani","manipul","manner.","map","map()","map(0","map(1","map(bob","map(task1","map[int,int]","mapel","mappartitionsrdd[23]","mapvalu","match","materialize.","math","matrices.dense(2,","matrix","matrix))","matrix:","matrix]","matrixd","matrixds:","matter","max,","meaning","mechan","member","members.","mention","merg","messag","method","method.","min\").","min(aptds('surface)),","min(aptds('surface)).cast[double],","min,","minim","minimum","minsurface:","mirror","mismatch;","miss","missing,","misspel","mistak","mix","ml","ml\"","ml'","model","model.","model.transform(testdata)","model.transform(testdatawithfeatures)","model.transform(testdatawithfeatures).as[housepriceprediction]","model.transform(testinput).as[housecitypredictionindexed]","model:","moder","modifi","modul","module,","modules:","monad","more","moreover,","mtl","much","multipl","mydat","mydate(jday:","n","n:","name","name.exists(set('x',","name:","namely,","names,","names/typ","names/types,","natur","need","needed:","neighborhood","neighborhood)","neighborhood,","neighborhood:","neighborhoodcount(neighborhood:","neighborhoods:","nest","new","newinstance(class","next","next,","nice,","nice|","nice|325000.0|","nil","nil)","nlplib","nlplib.uniquename(p.name)","non","none","none),","none).","none,","normal","not,","not.","note","noth","notifi","now","now,","null).","null|","null|450000.0|","number","number,","numer","obj#72:","obj#73:","object","object.","obtain","obviou","of)","offer","offici","often,","ok","olivierblanvillain","on","on(1,2,3,4).","onc","ontypeddataframe.","onward.","open","oper","operation.","operations,","operations:","opt","optim","optimizer)","option","option.","option[citybeds]","option[double]","option[double])","option[double])]","option[double],","option[int])","option[int])(implicit","option[int],","option[string],","option[x]","options.","order","order.","org.apache.spark.ml.linalg._","org.apache.spark.ml.linalg.matrix","org.apache.spark.ml.linalg.matrix)]","org.apache.spark.ml.linalg.matrix:","org.apache.spark.ml.linalg.matrixudt.","org.apache.spark.ml.linalg.vector","org.apache.spark.ml.linalg.vector),wronghousefeatures]","org.apache.spark.ml.linalg.vector)]","org.apache.spark.ml.linalg.vectorudt","org.apache.spark.rdd.rdd[(int,","org.apache.spark.rdd.rdd[(string,","org.apache.spark.rdd.rdd[(user,","org.apache.spark.rdd.rdd[(username,","org.apache.spark.sql,","org.apache.spark.sql.analysisexception:","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$$anonfun$apply$22.applyorelse(analyzer.scala:2503)","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$$anonfun$apply$22.applyorelse(analyzer.scala:2510)","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$.apply(analyzer.scala:2447)","org.apache.spark.sql.catalyst.analysis.analyzer$extractgenerator$.apply(analyzer.scala:2503)","org.apache.spark.sql.catalyst.analysis.analyzer.$anonfun$executeandcheck$1(analyzer.scala:173)","org.apache.spark.sql.catalyst.analysis.analyzer.$anonfun$executeandcheck$1(analyzer.scala:175)","org.apache.spark.sql.catalyst.analysis.analyzer.checkanalysis(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.analyzer.execute(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.analyzer.execute(analyzer.scala:189)","org.apache.spark.sql.catalyst.analysis.analyzer.executeandcheck(analyzer.scala:172)","org.apache.spark.sql.catalyst.analysis.analyzer.failanalysis(analyzer.scala:154)","org.apache.spark.sql.catalyst.analysis.analyzer.org$apache$spark$sql$catalyst$analysis$analyzer$$executesamecontext(analyzer.scala:195)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$$nestedinanonfun$checkanalysis$1$2.applyorelse(checkanalysis.scala:152)","org.apache.spark.sql.catalyst.analysis.checkanalysis$$anonfun$$nestedinanonfun$checkanalysis$1$2.applyorelse(checkanalysis.scala:155)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1$adapted(checkanalysis.scala:93)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1(checkanalysis.scala:152)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$1(checkanalysis.scala:299)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$12$adapted(checkanalysis.scala:272)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$12(checkanalysis.scala:272)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$15$adapted(checkanalysis.scala:299)","org.apache.spark.sql.catalyst.analysis.checkanalysis.$anonfun$checkanalysis$15(checkanalysis.scala:299)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkanalysis$(checkanalysis.scala:90)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkanalysis(checkanalysis.scala:93)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkvalidaggregateexpression$1(checkanalysis.scala:263)","org.apache.spark.sql.catalyst.analysis.checkanalysis.checkvalidaggregateexpression$1(checkanalysis.scala:272)","org.apache.spark.sql.catalyst.analysis.checkanalysis.failanalysis$(checkanalysis.scala:49)","org.apache.spark.sql.catalyst.analysis.checkanalysis.failanalysis(checkanalysis.scala:50)","org.apache.spark.sql.catalyst.analysis.package$analysiserrorat.failanalysis(package.scala:42)","org.apache.spark.sql.catalyst.encoders.expressionencoder$.apply(expressionencoder.scala:56)","org.apache.spark.sql.catalyst.plans.logical.analysishelper$.allowinvokingtransformsinanalyzer(analysishelper.scala:221)","org.apache.spark.sql.catalyst.plans.logical.analysishelper$.markinanalyzer(analysishelper.scala:228)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.$anonfun$resolveoperatorsup$1(analysishelper.scala:90)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.$anonfun$resolveoperatorsup$3(analysishelper.scala:90)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.resolveoperatorsup$(analysishelper.scala:84)","org.apache.spark.sql.catalyst.plans.logical.analysishelper.resolveoperatorsup(analysishelper.scala:86)","org.apache.spark.sql.catalyst.plans.logical.logicalplan.resolveoperatorsup(logicalplan.scala:29)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$1(queryplan.scala:116)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$3(queryplan.scala:132)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$mapexpressions$4(queryplan.scala:137)","org.apache.spark.sql.catalyst.plans.queryplan.$anonfun$transformexpressionsup$1(queryplan.scala:104)","org.apache.spark.sql.catalyst.plans.queryplan.mapexpressions(queryplan.scala:137)","org.apache.spark.sql.catalyst.plans.queryplan.recursivetransform$1(queryplan.scala:127)","org.apache.spark.sql.catalyst.plans.queryplan.recursivetransform$1(queryplan.scala:132)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpression$1(queryplan.scala:116)","org.apache.spark.sql.catalyst.plans.queryplan.transformexpressionsup(queryplan.scala:104)","org.apache.spark.sql.catalyst.queryplanningtracker$.withtracker(queryplanningtracker.scala:88)","org.apache.spark.sql.catalyst.queryplanningtracker.measurephase(queryplanningtracker.scala:111)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$execute$1$adapted(ruleexecutor.scala:205)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$execute$1(ruleexecutor.scala:213)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$execute$2(ruleexecutor.scala:216)","org.apache.spark.sql.catalyst.rules.ruleexecutor.$anonfun$executeandtrack$1(ruleexecutor.scala:183)","org.apache.spark.sql.catalyst.rules.ruleexecutor.execute(ruleexecutor.scala:205)","org.apache.spark.sql.catalyst.rules.ruleexecutor.executeandtrack(ruleexecutor.scala:183)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$1(scalareflection.scala:562)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$1(scalareflection.scala:591)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfor$6(scalareflection.scala:577)","org.apache.spark.sql.catalyst.scalareflection$.$anonfun$serializerfortype$1(scalareflection.scala:421)","org.apache.spark.sql.catalyst.scalareflection$.cleanupreflectionobjects(scalareflection.scala:49)","org.apache.spark.sql.catalyst.scalareflection$.serializerfor(scalareflection.scala:432)","org.apache.spark.sql.catalyst.scalareflection$.serializerfortype(scalareflection.scala:413)","org.apache.spark.sql.catalyst.scalareflection.cleanupreflectionobjects$(scalareflection.scala:903)","org.apache.spark.sql.catalyst.scalareflection.cleanupreflectionobjects(scalareflection.scala:904)","org.apache.spark.sql.catalyst.trees.currentorigin$.withorigin(treenode.scala:73)","org.apache.spark.sql.catalyst.trees.treenode.$anonfun$transformup$2(treenode.scala:341)","org.apache.spark.sql.catalyst.trees.treenode.foreachup(treenode.scala:183)","org.apache.spark.sql.catalyst.trees.treenode.mapproductiterator(treenode.scala:243)","org.apache.spark.sql.catalyst.trees.treenode.transformup(treenode.scala:341)","org.apache.spark.sql.datafram","org.apache.spark.sql.dataset","org.apache.spark.sql.dataset$.$anonfun$ofrows$1(dataset.scala:90)","org.apache.spark.sql.dataset$.ofrows(dataset.scala:88)","org.apache.spark.sql.dataset.(dataset.scala:210)","org.apache.spark.sql.dataset.(dataset.scala:216)","org.apache.spark.sql.dataset.select(dataset.scala:1462)","org.apache.spark.sql.dataset.select(dataset.scala:1517)","org.apache.spark.sql.dataset.withplan(dataset.scala:3715)","org.apache.spark.sql.dataset[apartment]","org.apache.spark.sql.dataset[foo]","org.apache.spark.sql.dataset[long]","org.apache.spark.sql.dataset[org.apache.spark.sql.row]","org.apache.spark.sql.encoders$.product(encoders.scala:285)","org.apache.spark.sql.errors.querycompilationerrors$.morethanonegeneratorerror(querycompilationerrors.scala:95)","org.apache.spark.sql.execution.queryexecution.$anonfun$analyzed$1(queryexecution.scala:73)","org.apache.spark.sql.execution.queryexecution.$anonfun$executephase$1(queryexecution.scala:143)","org.apache.spark.sql.execution.queryexecution.analyzed$lzycompute(queryexecution.scala:73)","org.apache.spark.sql.execution.queryexecution.analyzed(queryexecution.scala:71)","org.apache.spark.sql.execution.queryexecution.assertanalyzed(queryexecution.scala:63)","org.apache.spark.sql.execution.queryexecution.executephase(queryexecution.scala:143)","org.apache.spark.sql.functions.sum","org.apache.spark.sql.functions.{explod","org.apache.spark.sql.lowprioritysqlimplicits.newproductencoder$(sqlimplicits.scala:251)","org.apache.spark.sql.lowprioritysqlimplicits.newproductencoder(sqlimplicits.scala:251)","org.apache.spark.sql.sparksess","org.apache.spark.sql.sparksession.withactive(sparksession.scala:772)","org.apache.spark.sql.sqlcontext","org.apache.spark.sql.sqlimplicits.newproductencoder(sqlimplicits.scala:32)","org.apache.spark.sql.types.userdefinedtype[a]","org.apache.spark.{sparkconf,","origin","os","other:","otherwise(lit(0.0))).show(8).run()","other|","out","outer","outofmemoryerrors,","over","overaltasksperus","overaltasksperuser.collectasmap","overaltasksperuser:","overflow","overhead","overload","overview","overview):","p","packag","pair","parallelcollectionrdd[12]","parallelcollectionrdd[14]","parallelcollectionrdd[16]","parallelcollectionrdd[18]","parallelcollectionrdd[19]","paramet","parquet","parquet,","part","partial","particular","partitionfilters:","pass","peopl","people:","per","perform","performance.","perhap","person","person(age:","person(name:","person(r,","persond","personds:","phonebookentry(","phonebooks,","phonebooktf","phonenumber:","physic","pivot","pivot(aptds('bedrooms)).","pivot,","place","plain","plan","plan,","plan.","plan:","pleas","point,","polymorph","popul","popular","population:","possibl","potenti","practic","pre","precis","predicates.","predict","predict).","predictedcity:","predictedcityindexed.","predictedcityindexed:","predictedprice:","predictions.select(predictions.col('predictedcity)).collect.run()","predictions.select(predictions.col('predictedprice)).collect.run()","predictions:","prefer","preserv","previou","previous","price","price#1386,","price,","price/surfac","price:","price:double)","pricebyc","pricebycity.collect().run()","pricebycity:","pricebysurfaceunit","pricebysurfaceunit.collect().run()","pricebysurfaceunit.select(pricebysurfaceunit.ascol","pricebysurfaceunit:","pricee:","priceinfo","priceinfo(ratio:","priceinfo.show(2).run()","priceinfo2","priceinfo2(ratio:","priceinfo2.","priceinfo3","priceinfo3(ratio:","priceinfo3.","priceinfo:","pricemodifi","pricemodifier:","price|","price|bedrooms|","primit","println(data.cmax)","println(data.cmaxoption)","println(data.cmin)","println(data.cminoption)","println(data.csum)","println(data.csumoption)","probability:","probabl","problem","problem.","problemat","process","product","product,","product.","program","program,","programm","project","project,","project:","projections/selections.","proof","properli","properti","prove","provid","pst","public","pull","pushedfilters:","queri","question","quick","q|","r","rais","random","ratio","ratio:","ratio|","rawprediction:","rdd","rdd.","rdd:","rdd[(int,","rdd[(user,transactioncount)]","rdd[(username,timeseries)]","rdds,","read","readability.","readabl","readert","readert[io,","readi","readschema).","readschema:","real","reasons,","recommend","recurs","reducebykey","refer","referenc","reflect","relation[i#23l,j#24]","release,","releases.","remind","remov","repl\").set(\"spark.ui.enabled\",","replac","repres","represent","request","requests)","requests.","requir","required:","res16:","res17:","res18:","res19:","res1:","res20:","res2:","res30:","res31:","res32:","res33:","res38:","res45:","res46:","res4:","res5:","res6:","res8:","res9:","residents:","resolut","resolv","result","result.","result.run(spark).unsaferunsync()","result:","resultwithdescription:","rethought","retriev","return","reus","rf","rf.fit(indexeddata).run()","rf.fit(trainingdatawithfeatures)","rf.fit(trainingdatawithfeatures).run()","rf.fit(wrongtrainingdatawithfeatures)","rf:","rfinput","rfinputs(cityindexed:","rfinputs(price:","rfinputs.","right","right?","root","row","run","run()","run:","runtim","runtime.","s:","sadly,","safe","safe,","safe.","safeti","safety!","safety,","safety.","sale","same","sampl","sample.map(_.min)","samplestat","samplestats.show().run()","samplestats:","save","say,","sbt","sc.emptyrdd","sc.makerdd(","sc.makerdd((\"bob\",","sc.makerdd((1,","scala","scala,","scala.","scala.collection.abstracttraversable.map(traversable.scala:108)","scala.collection.immutable.list.foldleft(list.scala:91)","scala.collection.immutable.list.foreach(list.scala:431)","scala.collection.immutable.list.map(list.scala:293)","scala.collection.immutable.list.map(list.scala:305)","scala.collection.immutable.map[int,int]","scala.collection.immutable.sortedmap","scala.collection.immutable.sortedmap[string,int])]","scala.collection.linearseqoptimized.foldleft$(linearseqoptimized.scala:122)","scala.collection.linearseqoptimized.foldleft(linearseqoptimized.scala:126)","scala.collection.map[string,scala.collection.immutable.sortedmap[string,int]]","scala.collection.map[user,transactioncount]","scala.collection.mutable.arraybuffer.foreach(arraybuffer.scala:49)","scala.collection.mutable.resizablearray.foreach$(resizablearray.scala:55)","scala.collection.mutable.resizablearray.foreach(resizablearray.scala:62)","scala.collection.traversablelike.$anonfun$map$1(traversablelike.scala:285)","scala.collection.traversablelike.map$(traversablelike.scala:278)","scala.collection.traversablelike.map(traversablelike.scala:285)","scala.reflect.classtag[option[int]])frameless.typedcolumn[w,option[int]]","scala.reflect.internal.tpe.typeconstraints$undolog.undo(typeconstraints.scala:73)","scala>","scalar","scalar,","scalareflect","schema","schema.","seal","second","second,","secondari","section","see","see,","seem","select","select()","select().","select,","select[c","selectintstring(tf:","selectintstringtypo(tf:","selectmany()","selectmany(),","semigroup","sense,","separately,","seq(","seq(daterange(new","seq(person(42,","seq[(string,","seq[citybeds]","seq[double]","seq[person]","seq[string]","sequenc","serial","serializ","serializefromobject","serv","set","sever","shadow","shapeless","shapeless'","shapeless.hlist","shapeless.tag.tagged[string(\"citi\")]","shapeless.tag.tagged[string(\"x\")]","shell","shorter","show","show()","show(1).run()","showcas","shown","shuffledrdd[15]","shuffledrdd[17]","sign","signatur","signatures:","similar","similar)","similarly,","simpl","simpli","simplifi","simplist","simply:","since,","singl","situat","size","sizes.","skip","slow","small","snippet,","solut","solv","some(10).map(c","some(3))","some(300000.0),","some(450000.0),","some(50),","some(citybeds(paris,2))","sort","sortedmap(\"task1\"","sortedmap(\"task3\"","sorting.","sourc","spark","spark'","spark).","spark,","spark.","spark.createdataset(","spark.createdataset(apartments)","spark.createdataset(seq(mydate(new","spark.createdataset(seq(new","spark.implicits._","spark.read.parquet(\"/tmp/foo\").as[foo]","spark.sparkcontext.setloglevel(\"warn\")","spark:","sparkconf().setmaster(\"local[*]\").setappname(\"frameless","sparkcontext}","sparkdelay","sparkdelay[f[_]]","sparkdelay[f].","sparkexplode($\"_2\"))","sparkexplode}","sparksess","sparksession,","sparksession.","sparksession.builder().config(conf).appname(\"repl\").getorcreate()","specifi","sqlcontext):","squar","squarefeet:","stack","stack.","stack:","stage","standard","start","stat","statement","statement).","stats(","stay","still","store","strict","stridx_267bc5cb88b4","string","string(\"abc\")","string)","string),updatedsurface]","string):","string)]","string)])","string)],","string,","string.","string]","stringindexerinput","stringindexerinput(city:","stringindexermodel","strongli","struct","struct,","struct]","structur","subsequ","subset","such","suffer","suffici","suggests,","suite:","sum","sum(i)#164l,","sum,","summari","suppli","support","suppos","surfac","surface#1385,","surface,","surface:","surface];","suspend","suspended.","suspens","symbol","syntax","syntax.","syntax:","syntaxes.","system","systems,","t","t.withcolumntupled(","t2","t2.dataset.todf().select(sparkexplode($\"_2\"),","t2.explode('_2):","t2:","t:","t]","tabl","table,","tables:","take","target","task","task2","task3","tdataframe[schema","tdataframe[schema]","techniqu","tell","term","test","test.","testdata","testdata.","testdata:","testdatawithfeatur","testdatawithfeatures:","testinput","testinput:","tests.","tf.select('i,","tf.select('j,","tf1.innerjoin(tf2).on('s).and('j)","tf1.innerjoin(tf2).using('i)","tf2:","thank","then,","therefore,","thing","this.","those","thread","three","through","throw","thunk","time","time,","time.","time:","timeseri","timeseries)]","togeth","together.","top","topic","totalperus","totalperuser.collectasmap","totalperuser:","toy","trace):","trace,","track","track,","train","trainingdata","trainingdata:","trainingdatawithfeatur","trainingdatawithfeatures:","trait","transactioncount","transactioncount)]","transform","transformations.","tri","troubl","true,","tt,","tune","tupl","tuple23","tutori","tutorial.","two","two.","type","type)","type,","type.","type:","type;","typeclass","typeclass,","typeclass:","typedaggreg","typedcolumn","typedd","typeddatafram","typeddataframe,","typeddataframe[(int,","typeddataframe[(string,","typeddataframe[bar])","typeddataframe[citymapentry])","typeddataframe[citymapentry].","typeddataframe[foo]):","typeddataframe[foo],","typeddataframe[phonebookentry]","typeddataframe[phonebookentry],","typeddataset","typeddataset'","typeddataset,","typeddataset.","typeddataset.create(1","typeddataset.create(apartments)","typeddataset.create(apartmentsopt)","typeddataset.create(aptds)","typeddataset.create(cityinfo)","typeddataset.create(ds)","typeddataset.create(people)","typeddataset.create(seq(","typeddataset.create(seq(\"label\"","typeddataset.create(seq((1,","typeddataset.create(seq(daterange(new","typeddataset.create(seq(foo(1,","typeddataset.create(seq(foodate(1,","typeddataset.create(seq(housedata(120,","typeddataset.create(seq(housedata(20,","typeddataset.create(seq(housedata(70,","typeddataset.create(seq(mydate(new","typeddataset.create(seq(wronghousedata(20,","typeddataset:","typeddataset[(apartment,","typeddataset[(string,","typeddataset[(string,int)]","typeddataset[a]","typeddataset[apartment]","typeddataset[apartment]:","typeddataset[apartmentshortinfo]","typeddataset[citybeds]","typeddataset[daterange]","typeddataset[double])","typeddataset[foo]","typeddataset[foodate]","typeddataset[long].","typeddataset[string]","typeddataset[t]","typeddataset[tuple1[a]].","typeddataset[tuple1[long]]","typeddataset[tuplen[...]]","typeddataset[u]","typeddatasets.","typeddatset.","typedds:","typedencod","typedencoder[a]","typedestim","typedestimator,","typedestimators,","typedindextostr","typedindextostring[indextostringinput](indexermodel.transformer.labels)","typedrandomforestclassifi","typedrandomforestclassifier.","typedrandomforestclassifier[rfinputs]","typedrandomforestregressor","typedrandomforestregressor.","typedrandomforestregressor[rfinputs]","typedrandomforestregressor[wrongrfinputs]","typedstringindex","typedstringindexer[stringindexerinput]","typedtransform","typedtransformercan","typedvectorassembl","typedvectorassembler[features]","typedvectorassembler[wrongfeatures]","typeencod","typelevel","types)","types,","types.","types:","typesaf","typesafeti","typo","typo,","u","udf","udf()","udf().","udf(aptds('city),","udf:","ui","unabl","under","underli","unfortun","unfortunately,","union","uniqu","uniquename(name:","unit:","unlik","unsaf","unwrap","up","up,","updat","updated.show(2).run()","updated:","updatedsurfac","updatedsurface(city:","us","usag","user","user'","usernam","usual","util","val","valid","valu","value#158l]","value#74l]","value,","value.","value:","values.","value|","vanilla","variabl","variou","vector","vector)","vector))","vector,","vector:","vector[string])","vector]","vectorassembl","vectorassembler)","vectorassembler.transform(testdata).as[housedatawithfeatures]","vectorassembler.transform(trainingdata).as[housedatawithfeatures]","vectorassembler:","vectord","vectords:","vectors.dense(1,","vectors:","verbos","veri","verifi","version","versions.","via","view","vs","w:","w](other:","want","warning:","way","way,","well","well,","well.","when(apttypedds2('city)","when/otherwis","whenev","wherea","why?","window","with,","with:","withcityinfo","withcityinfo.colmany('_1,","withcityinfo.colmany('_2,","withcityinfo.select(","withcityinfo.show().run()","withcityinfo:","withcolumn()","withcolumn[citybedsother](lit(list(\"a\",\"b\",\"c\"))).","withcolumntupled()","withdescription(\"sampl","withgroupid(\"samplingjob\").","without","won't","work","work,","worked,","world\")","world|","wrap","wrappedarray((nice,325000.0),","wrappedarray(296250.0)","wrappedarray(6000.0,","wrappedarray(citybeds(paris,2),","wrappedarray(san","written","wrong","wrongfeatur","wrongfeatures(squarefeet:","wronghousedata","wronghousedata(squarefeet:","wronghousedata?","wronghousefeatures(","wrongrfinput","wrongrfinputs(labelofwrongtype:","wrongtrainingdata","wrongtrainingdata:","wrongtrainingdatawithfeatur","wrongtrainingdatawithfeatures:","w|","w})frameless.typedcolumn[w,option[int]]","w})frameless.typedcolumn[w,out]","w},","x","x.","x:","yet.","zero.","{","{lyon,","{nice,","|","|+|","|1000|102|","|100|","|12000.0|","|200000.0|","|276333.3333333333|62.833333333333336|","|300000.0|450000.0|","|4500.0|450000.0|","|6000.0|300000.0|","|6908333.333333333|12.566666666666668|hello","|city|surface|","|lyon|","|null|null|","|paris|","|paris|250000.0|","|paris|300000.0|","|paris|4500.0|","|paris|450000.0|","|paris|500000.0|","|paris|6000.0|","|paris|600000.0|","|paris|900000.0|","|paris|[a,","|paris|[abc,","|value|","|{lyon,","|{nice,","|{paris,","}","})","},"],"pipeline":["stopWordFilter","stemmer"]},"store":{"./":{"url":"./","title":"Introduction","keywords":"","body":"Frameless\n\n\n\n\nFrameless is a Scala library for working with Spark using more expressive types. \nIt consists of the following modules:\n\nframeless-dataset for a more strongly typed Dataset/DataFrame API \nframeless-ml for a more strongly typed Spark ML API based on frameless-dataset\nframeless-cats for using Spark's RDD API with cats\n\nNote that while Frameless is still getting off the ground, it is very possible that breaking changes will be\nmade for at least the next few versions.\nThe Frameless project and contributors support the\nTypelevel Code of Conduct and want all its\nassociated channels (e.g. GitHub, Gitter) to be a safe and friendly environment for contributing and learning.\nVersions and dependencies\nThe compatible versions of Spark and \ncats are as follows: \n\n\n\nFrameless\nSpark\nCats\nCats-Effect\nScala\n\n\n\n\n0.4.0\n2.2.0\n1.0.0-IF\n0.4\n2.11\n\n\n0.4.1\n2.2.0\n1.x\n0.8\n2.11\n\n\n0.5.2\n2.2.1\n1.x\n0.8\n2.11\n\n\n0.6.1\n2.3.0\n1.x\n0.8\n2.11\n\n\n0.7.0\n2.3.1\n1.x\n1.x\n2.11\n\n\n0.8.0\n2.4.0\n1.x\n1.x\n2.11/2.12\n\n\n0.9.0\n3.0.0\n1.x\n1.x\n2.12\n\n\n\nVersions 0.5.x and 0.6.x have identical features. The first is compatible with Spark 2.2.1 and the second with 2.3.0. \nThe only dependency of the frameless-dataset module is on shapeless 2.3.2. \nTherefore, depending on frameless-dataset, has a minimal overhead on your Spark's application jar. \nOnly the frameless-cats module depends on cats and cats-effect, so if you prefer to work just with Datasets and not with RDDs, \nyou may choose not to depend on frameless-cats. \nFrameless intentionally does not have a compile dependency on Spark. \nThis essentially allows you to use any version of Frameless with any version of Spark. \nThe aforementioned table simply provides the versions of Spark we officially compile \nand test Frameless with, but other versions may probably work as well. \nBreaking changes in 0.9\n\nSpark 3 introduces a new ExpressionEncoder approach, the schema for single value DataFrame's is now \"value\" not \"_1\". \n\nWhy?\nFrameless introduces a new Spark API, called TypedDataset. \nThe benefits of using TypedDataset compared to the standard Spark Dataset API are as follows:\n\nTypesafe columns referencing (e.g., no more runtime errors when accessing non-existing columns)\nCustomizable, typesafe encoders (e.g., if a type does not have an encoder, it should not compile) \nEnhanced type signature for built-in functions (e.g., if you apply an arithmetic operation on a non-numeric column, you \nget a compilation error)\nTypesafe casting and projections\n\nClick here for a \ndetailed comparison of TypedDataset with Spark's Dataset API. \nDocumentation\n\nTypedDataset: Feature Overview\nTyped Spark ML\nComparing TypedDatasets with Spark's Datasets\nTyped Encoders in Frameless\nInjection: Creating Custom Encoders\nJob[A]\nUsing Cats with RDDs\nProof of Concept: TypedDataFrame\n\nQuick Start\nSince the 0.9.x release, Frameless is compiled only against Scala 2.12.x.\nTo use Frameless in your project add the following in your build.sbt file as needed:\nval framelessVersion = \"0.9.0\" // for Spark 3.0.0\n\nlibraryDependencies ++= List(\n \"org.typelevel\" %% \"frameless-dataset\" % framelessVersion,\n \"org.typelevel\" %% \"frameless-ml\" % framelessVersion,\n \"org.typelevel\" %% \"frameless-cats\" % framelessVersion \n)\n\nAn easy way to bootstrap a Frameless sbt project:\n\nif you have Giter8 installed then simply:\n\ng8 imarios/frameless.g8\n\n\nwith sbt >= 0.13.13:\n\nsbt new imarios/frameless.g8\n\nTyping sbt console inside your project will bring up a shell with Frameless\nand all its dependencies loaded (including Spark).\nNeed help?\nFeel free to messages us on our gitter \nchannel for any issues/questions.\nDevelopment\nWe require at least one sign-off (thumbs-up, +1, or similar) to merge pull requests. The current maintainers\n(people who can merge pull requests) are:\n\nadelbertc\nimarios\nkanterov\nnon\nOlivierBlanvillain\n\nTesting\nFrameless contains several property tests. To avoid OutOfMemoryErrors, we\ntune the default generator sizes. The following environment variables may\nbe set to adjust the size of generated collections in the TypedDataSet suite:\n\n\n\nProperty\nDefault\n\n\n\n\nFRAMELESS_GEN_MIN_SIZE\n0\n\n\nFRAMELESS_GEN_SIZE_RANGE\n20\n\n\n\nLicense\nCode is provided under the Apache 2.0 license available at http://opensource.org/licenses/Apache-2.0,\nas well as in the LICENSE file. This is the same license used as Spark.\n"},"FeatureOverview.html":{"url":"FeatureOverview.html","title":"TypedDataset: Feature Overview","keywords":"","body":"TypedDataset: Feature Overview\nThis tutorial introduces TypedDataset using a simple example.\nThe following imports are needed to make all code examples compile.\nimport org.apache.spark.{SparkConf, SparkContext}\nimport org.apache.spark.sql.SparkSession\nimport frameless.functions.aggregate._\nimport frameless.TypedDataset\n\nval conf = new SparkConf().setMaster(\"local[*]\").setAppName(\"Frameless repl\").set(\"spark.ui.enabled\", \"false\")\nimplicit val spark = SparkSession.builder().config(conf).appName(\"REPL\").getOrCreate()\nspark.sparkContext.setLogLevel(\"WARN\")\n\nimport spark.implicits._\n\nCreating TypedDataset instances\nWe start by defining a case class:\ncase class Apartment(city: String, surface: Int, price: Double, bedrooms: Int)\n\nAnd few Apartment instances:\nval apartments = Seq(\n Apartment(\"Paris\", 50, 300000.0, 2),\n Apartment(\"Paris\", 100, 450000.0, 3),\n Apartment(\"Paris\", 25, 250000.0, 1),\n Apartment(\"Lyon\", 83, 200000.0, 2),\n Apartment(\"Lyon\", 45, 133000.0, 1),\n Apartment(\"Nice\", 74, 325000.0, 3)\n)\n\nWe are now ready to instantiate a TypedDataset[Apartment]:\nval aptTypedDs = TypedDataset.create(apartments)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nWe can also create one from an existing Spark Dataset:\nval aptDs = spark.createDataset(apartments)\n// aptDs: org.apache.spark.sql.Dataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval aptTypedDs = TypedDataset.create(aptDs)\n// aptTypedDs: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nOr use the Frameless syntax:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval aptTypedDs2 = aptDs.typed\n// aptTypedDs2: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nTypesafe column referencing\nThis is how we select a particular column from a TypedDataset:\nval cities: TypedDataset[String] = aptTypedDs.select(aptTypedDs('city))\n// cities: frameless.TypedDataset[String] = [value: string]\n\nThis is completely type-safe, for instance suppose we misspell city as citi:\naptTypedDs.select(aptTypedDs('citi))\n// :27: error: No column Symbol with shapeless.tag.Tagged[String(\"citi\")] of type A in Apartment\n// aptTypedDs.select(aptTypedDs('citi))\n// ^\n\nThis gets raised at compile time, whereas with the standard Dataset API the error appears at runtime (enjoy the stack trace):\naptDs.select('citi)\n// org.apache.spark.sql.AnalysisException: cannot resolve '`citi`' given input columns: [bedrooms, city, price, surface];\n// 'Project ['citi]\n// +- LocalRelation [city#1384, surface#1385, price#1386, bedrooms#1387]\n// \n// at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:155)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:152)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.$anonfun$transformUp$2(TreeNode.scala:341)\n// at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:341)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$transformExpressionsUp$1(QueryPlan.scala:104)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$1(QueryPlan.scala:116)\n// at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:116)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:127)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$3(QueryPlan.scala:132)\n// at scala.collection.TraversableLike.$anonfun$map$1(TraversableLike.scala:285)\n// at scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n// at scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n// at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n// at scala.collection.TraversableLike.map(TraversableLike.scala:285)\n// at scala.collection.TraversableLike.map$(TraversableLike.scala:278)\n// at scala.collection.AbstractTraversable.map(Traversable.scala:108)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:132)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$4(QueryPlan.scala:137)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:243)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:137)\n// at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:104)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1(CheckAnalysis.scala:152)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1$adapted(CheckAnalysis.scala:93)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:183)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:93)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:90)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:154)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:175)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)\n// at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)\n// at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)\n// at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)\n// at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n// at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)\n// at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)\n// at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)\n// at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)\n// at org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:90)\n// at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n// at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:88)\n// at org.apache.spark.sql.Dataset.withPlan(Dataset.scala:3715)\n// at org.apache.spark.sql.Dataset.select(Dataset.scala:1462)\n// ... 42 elided\n\nselect() supports arbitrary column operations:\naptTypedDs.select(aptTypedDs('surface) * 10, aptTypedDs('surface) + 2).show().run()\n// +----+---+\n// | _1| _2|\n// +----+---+\n// | 500| 52|\n// |1000|102|\n// | 250| 27|\n// | 830| 85|\n// | 450| 47|\n// | 740| 76|\n// +----+---+\n//\n\nNote that unlike the standard Spark API, where some operations are lazy and some are not, all TypedDatasets operations are lazy.\nIn the above example, show() is lazy. It requires to apply run() for the show job to materialize.\nA more detailed explanation of Job is given here.\nNext we compute the price by surface unit:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// :26: error: overloaded method value / with alternatives:\n// (u: Double)(implicit n: frameless.CatalystNumeric[Double])frameless.TypedColumn[Apartment,Double] \n// [Out, TT, W](other: frameless.TypedColumn[TT,Double])(implicit n: frameless.CatalystDivisible[Double,Out], implicit e: frameless.TypedEncoder[Out], implicit w: frameless.With[Apartment,TT]{type Out = W})frameless.TypedColumn[W,Out]\n// cannot be applied to (frameless.TypedColumn[Apartment,Int])\n// val priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface))\n// ^\n\nAs the error suggests, we can't divide a TypedColumn of Double by Int.\nFor safety, in Frameless only math operations between same types is allowed:\nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [value: double]\n\npriceBySurfaceUnit.collect().run()\n// res4: Seq[Double] = WrappedArray(6000.0, 4500.0, 10000.0, 2409.6385542168673, 2955.5555555555557, 4391.891891891892)\n\nLooks like it worked, but that cast seems unsafe right? Actually it is safe.\nLet's try to cast a TypedColumn of String to Double:\naptTypedDs('city).cast[Double]\n// :27: error: could not find implicit value for parameter c: frameless.CatalystCast[String,Double]\n// aptTypedDs('city).cast[Double]\n// ^\n\nThe compile-time error tells us that to perform the cast, an evidence\n(in the form of CatalystCast[String, Double]) must be available.\nSince casting from String to Double is not allowed, this results\nin a compilation error.\nCheck here\nfor the set of available CatalystCast.\nWorking with Optional columns\nWhen working with real data we have to deal with imperfections, such as missing fields. Columns that may have\nmissing data should be represented using Options. For this example, let's assume that the Apartments dataset\nmay have missing values. \ncase class ApartmentOpt(city: Option[String], surface: Option[Int], price: Option[Double], bedrooms: Option[Int])\n\nval apartmentsOpt = Seq(\n ApartmentOpt(Some(\"Paris\"), Some(50), Some(300000.0), None),\n ApartmentOpt(None, None, Some(450000.0), Some(3))\n)\n\nval aptTypedDsOpt = TypedDataset.create(apartmentsOpt)\n// aptTypedDsOpt: frameless.TypedDataset[ApartmentOpt] = [city: string, surface: int ... 2 more fields]\n\naptTypedDsOpt.show().run()\n// +-----+-------+--------+--------+\n// | city|surface| price|bedrooms|\n// +-----+-------+--------+--------+\n// |Paris| 50|300000.0| null|\n// | null| null|450000.0| 3|\n// +-----+-------+--------+--------+\n//\n\nUnfortunately the syntax used above with select() will not work here:\naptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()\n// :27: error: overloaded method value * with alternatives:\n// (u: Option[Int])(implicit n: frameless.CatalystNumeric[Option[Int]])frameless.TypedColumn[ApartmentOpt,Option[Int]] \n// [TT, W](other: frameless.TypedColumn[TT,Option[Int]])(implicit n: frameless.CatalystNumeric[Option[Int]], implicit w: frameless.With[ApartmentOpt,TT]{type Out = W}, implicit t: scala.reflect.ClassTag[Option[Int]])frameless.TypedColumn[W,Option[Int]]\n// cannot be applied to (Int)\n// aptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()\n// ^\n// :27: error: overloaded method value + with alternatives:\n// (u: Option[Int])(implicit n: frameless.CatalystNumeric[Option[Int]])frameless.TypedColumn[ApartmentOpt,Option[Int]] \n// [TT, W](other: frameless.TypedColumn[TT,Option[Int]])(implicit n: frameless.CatalystNumeric[Option[Int]], implicit w: frameless.With[ApartmentOpt,TT]{type Out = W})frameless.TypedColumn[W,Option[Int]]\n// cannot be applied to (Int)\n// aptTypedDsOpt.select(aptTypedDsOpt('surface) * 10, aptTypedDsOpt('surface) + 2).show().run()\n// ^\n\nThis is because we cannot multiple an Option with an Int. In Scala, Option has a map() method to help address\nexactly this (e.g., Some(10).map(c => c * 2)). Frameless follows a similar convention. By applying the opt method on \nany Option[X] column you can then use map() to provide a function that works with the unwrapped type X. \nThis is best shown in the example bellow:\nscala> aptTypedDsOpt.select(aptTypedDsOpt('surface).opt.map(c => c * 10), aptTypedDsOpt('surface).opt.map(_ + 2)).show().run()\n+----+----+\n| _1| _2|\n+----+----+\n| 500| 52|\n|null|null|\n+----+----+\n\nKnown issue: map() will throw a runtime exception when the applied function includes a udf(). If you want to \napply a udf() to an optional column, we recommend changing your udf to work directly with Optional fields. \nCasting and projections\nIn the general case, select() returns a TypedDataset of type TypedDataset[TupleN[...]] (with N in [1...10]).\nFor example, if we select three columns with types String, Int, and Boolean the result will have type\nTypedDataset[(String, Int, Boolean)]. \nWe often want to give more expressive types to the result of our computations.\nas[T] allows us to safely cast a TypedDataset[U] to another of type TypedDataset[T] as long\nas the types in U and T align.\nWhen the cast is valid the expression compiles:\ncase class UpdatedSurface(city: String, surface: Int)\n// defined class UpdatedSurface\n\nval updated = aptTypedDs.select(aptTypedDs('city), aptTypedDs('surface) + 2).as[UpdatedSurface]\n// updated: frameless.TypedDataset[UpdatedSurface] = [city: string, surface: int]\n\nupdated.show(2).run()\n// +-----+-------+\n// | city|surface|\n// +-----+-------+\n// |Paris| 52|\n// |Paris| 102|\n// +-----+-------+\n// only showing top 2 rows\n//\n\nNext we try to cast a (String, String) to an UpdatedSurface (which has types String, Int).\nThe cast is not valid and the expression does not compile:\naptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// :29: error: could not find implicit value for parameter as: frameless.ops.As[(String, String),UpdatedSurface]\n// aptTypedDs.select(aptTypedDs('city), aptTypedDs('city)).as[UpdatedSurface]\n// ^\n\nAdvanced topics with select()\nWhen you select() a single column that has type A, the resulting type is TypedDataset[A] and \nnot TypedDataset[Tuple1[A]]. This behavior makes working with nested schema easier (i.e., in the case \nwhere A is a complex data type) and simplifies type-checking column operations (e.g., verify that two \ncolumns can be added, divided, etc.). However, when A is scalar, say a Long, it makes it harder to select \nand work with the resulting TypedDataset[Long]. For instance, it's harder to reference this single scalar \ncolumn using select(). If this becomes an issue, you can bypass this behavior by using the \nselectMany() method instead of select(). In the previous example, selectMany() will return\nTypedDataset[Tuple1[Long]] and you can reference its single column using the name _1. \nselectMany() should also be used when you need to select more than 10 columns. \nselect() has better IDE support and compiles faster than the macro based selectMany(), \nso prefer select() for the most common use cases.\nWhen you are handed a single scalar column TypedDataset (e.g., TypedDataset[Double]) \nthe best way to reference its single column is using the asCol (short for \"as a column\") method. \nThis is best shown in the example below. We will see more usages of asCol later in this tutorial. \nval priceBySurfaceUnit = aptTypedDs.select(aptTypedDs('price) / aptTypedDs('surface).cast[Double])\n// priceBySurfaceUnit: frameless.TypedDataset[Double] = [value: double]\n\npriceBySurfaceUnit.select(priceBySurfaceUnit.asCol * 2).show(2).run()\n// +-------+\n// | value|\n// +-------+\n// |12000.0|\n// | 9000.0|\n// +-------+\n// only showing top 2 rows\n//\n\nProjections\nWe often want to work with a subset of the fields in a dataset.\nProjections allow us to easily select our fields of interest\nwhile preserving their initial names and types for extra safety.\nHere is an example using the TypedDataset[Apartment] with an additional column:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\ncase class ApartmentDetails(city: String, price: Double, surface: Int, ratio: Double)\n// defined class ApartmentDetails\n\nval aptWithRatio =\n aptds.select(\n aptds('city),\n aptds('price),\n aptds('surface),\n aptds('price) / aptds('surface).cast[Double]\n ).as[ApartmentDetails]\n// aptWithRatio: frameless.TypedDataset[ApartmentDetails] = [city: string, price: double ... 2 more fields]\n\nSuppose we only want to work with city and ratio:\ncase class CityInfo(city: String, ratio: Double)\n// defined class CityInfo\n\nval cityRatio = aptWithRatio.project[CityInfo]\n// cityRatio: frameless.TypedDataset[CityInfo] = [city: string, ratio: double]\n\ncityRatio.show(2).run()\n// +-----+------+\n// | city| ratio|\n// +-----+------+\n// |Paris|6000.0|\n// |Paris|4500.0|\n// +-----+------+\n// only showing top 2 rows\n//\n\nSuppose we only want to work with price and ratio:\ncase class PriceInfo(ratio: Double, price: Double)\n// defined class PriceInfo\n\nval priceInfo = aptWithRatio.project[PriceInfo]\n// priceInfo: frameless.TypedDataset[PriceInfo] = [ratio: double, price: double]\n\npriceInfo.show(2).run()\n// +------+--------+\n// | ratio| price|\n// +------+--------+\n// |6000.0|300000.0|\n// |4500.0|450000.0|\n// +------+--------+\n// only showing top 2 rows\n//\n\nWe see that the order of the fields does not matter as long as the\nnames and the corresponding types agree. However, if we make a mistake in\nany of the names and/or their types, then we get a compilation error.\nSay we make a typo in a field name:\ncase class PriceInfo2(ratio: Double, pricEE: Double)\n\naptWithRatio.project[PriceInfo2]\n// :29: error: Cannot prove that ApartmentDetails can be projected to PriceInfo2. Perhaps not all member names and types of PriceInfo2 are the same in ApartmentDetails?\n// aptWithRatio.project[PriceInfo2]\n// ^\n\nSay we make a mistake in the corresponding type:\ncase class PriceInfo3(ratio: Int, price: Double) // ratio should be Double\n\naptWithRatio.project[PriceInfo3]\n// :29: error: Cannot prove that ApartmentDetails can be projected to PriceInfo3. Perhaps not all member names and types of PriceInfo3 are the same in ApartmentDetails?\n// aptWithRatio.project[PriceInfo3]\n// ^\n\nUnion of TypedDatasets\nLets create a projection of our original dataset with a subset of the fields.\ncase class ApartmentShortInfo(city: String, price: Double, bedrooms: Int)\n\nval aptTypedDs2: TypedDataset[ApartmentShortInfo] = aptTypedDs.project[ApartmentShortInfo]\n\nThe union of aptTypedDs2 with aptTypedDs uses all the fields of the caller (aptTypedDs2)\nand expects the other dataset (aptTypedDs) to include all those fields. \nIf field names/types do not match you get a compilation error. \naptTypedDs2.union(aptTypedDs).show().run\n// +-----+--------+--------+\n// | city| price|bedrooms|\n// +-----+--------+--------+\n// |Paris|300000.0| 2|\n// |Paris|450000.0| 3|\n// |Paris|250000.0| 1|\n// | Lyon|200000.0| 2|\n// | Lyon|133000.0| 1|\n// | Nice|325000.0| 3|\n// |Paris|300000.0| 2|\n// |Paris|450000.0| 3|\n// |Paris|250000.0| 1|\n// | Lyon|200000.0| 2|\n// | Lyon|133000.0| 1|\n// | Nice|325000.0| 3|\n// +-----+--------+--------+\n//\n\nThe other way around will not compile, since aptTypedDs2 has only a subset of the fields. \naptTypedDs.union(aptTypedDs2).show().run\n// :28: error: Cannot prove that ApartmentShortInfo can be projected to Apartment. Perhaps not all member names and types of Apartment are the same in ApartmentShortInfo?\n// aptTypedDs.union(aptTypedDs2).show().run\n// ^\n\nFinally, as with project, union will align fields that have same names/types,\nso fields do not have to be in the same order. \nTypedDataset functions and transformations\nFrameless supports many of Spark's functions and transformations. \nHowever, whenever a Spark function does not exist in Frameless, \ncalling .dataset will expose the underlying \nDataset (from org.apache.spark.sql, the original Spark APIs), \nwhere you can use anything that would be missing from the Frameless' API.\nThese are the main imports for Frameless' aggregate and non-aggregate functions.\nimport frameless.functions._ // For literals\nimport frameless.functions.nonAggregate._ // e.g., concat, abs\nimport frameless.functions.aggregate._ // e.g., count, sum, avg\n\nDrop/Replace/Add fields\ndropTupled() drops a single column and results in a tuple-based schema.\naptTypedDs2.dropTupled('price): TypedDataset[(String,Int)]\n// res18: frameless.TypedDataset[(String, Int)] = [_1: string, _2: int]\n\nTo drop a column and specify a new schema use drop().\ncase class CityBeds(city: String, bedrooms: Int)\n// defined class CityBeds\n\nval cityBeds: TypedDataset[CityBeds] = aptTypedDs2.drop[CityBeds] \n// cityBeds: frameless.TypedDataset[CityBeds] = [city: string, bedrooms: int]\n\nOften, you want to replace an existing column with a new value.\nval inflation = aptTypedDs2.withColumnReplaced('price, aptTypedDs2('price) * 2)\n// inflation: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]\n\ninflation.show(2).run()\n// +-----+--------+--------+\n// | city| price|bedrooms|\n// +-----+--------+--------+\n// |Paris|600000.0| 2|\n// |Paris|900000.0| 3|\n// +-----+--------+--------+\n// only showing top 2 rows\n//\n\nOr use a literal instead.\nimport frameless.functions.lit\n// import frameless.functions.lit\n\naptTypedDs2.withColumnReplaced('price, lit(0.001)) \n// res20: frameless.TypedDataset[ApartmentShortInfo] = [city: string, price: double ... 1 more field]\n\nAdding a column using withColumnTupled() results in a tupled-based schema.\naptTypedDs2.withColumnTupled(lit(Array(\"a\",\"b\",\"c\"))).show(2).run()\n// +-----+--------+---+---------+\n// | _1| _2| _3| _4|\n// +-----+--------+---+---------+\n// |Paris|300000.0| 2|[a, b, c]|\n// |Paris|450000.0| 3|[a, b, c]|\n// +-----+--------+---+---------+\n// only showing top 2 rows\n//\n\nSimilarly, withColumn() adds a column and explicitly expects a schema for the result.\ncase class CityBedsOther(city: String, bedrooms: Int, other: List[String])\n// defined class CityBedsOther\n\ncityBeds.\n withColumn[CityBedsOther](lit(List(\"a\",\"b\",\"c\"))).\n show(1).run()\n// +-----+--------+---------+\n// | city|bedrooms| other|\n// +-----+--------+---------+\n// |Paris| 2|[a, b, c]|\n// +-----+--------+---------+\n// only showing top 1 row\n//\n\nTo conditionally change a column use the when/otherwise operation. \nimport frameless.functions.nonAggregate.when\n// import frameless.functions.nonAggregate.when\n\naptTypedDs2.withColumnTupled(\n when(aptTypedDs2('city) === \"Paris\", aptTypedDs2('price)).\n when(aptTypedDs2('city) === \"Lyon\", lit(1.1)).\n otherwise(lit(0.0))).show(8).run()\n// +-----+--------+---+--------+\n// | _1| _2| _3| _4|\n// +-----+--------+---+--------+\n// |Paris|300000.0| 2|300000.0|\n// |Paris|450000.0| 3|450000.0|\n// |Paris|250000.0| 1|250000.0|\n// | Lyon|200000.0| 2| 1.1|\n// | Lyon|133000.0| 1| 1.1|\n// | Nice|325000.0| 3| 0.0|\n// +-----+--------+---+--------+\n//\n\nA simple way to add a column without losing important schema information is\nto project the entire source schema into a single column using the asCol() method.\nval c = cityBeds.select(cityBeds.asCol, lit(List(\"a\",\"b\",\"c\")))\n// c: frameless.TypedDataset[(CityBeds, List[String])] = [_1: struct, _2: array]\n\nc.show(1).run()\n// +----------+---------+\n// | _1| _2|\n// +----------+---------+\n// |{Paris, 2}|[a, b, c]|\n// +----------+---------+\n// only showing top 1 row\n//\n\nWhen working with Spark's DataFrames, you often select all columns using .select($\"*\", ...). \nIn a way, asCol() is a typed equivalent of $\"*\". \nTo access nested columns, use the colMany() method. \nc.select(c.colMany('_1, 'city), c('_2)).show(2).run()\n// +-----+---------+\n// | _1| _2|\n// +-----+---------+\n// |Paris|[a, b, c]|\n// |Paris|[a, b, c]|\n// +-----+---------+\n// only showing top 2 rows\n//\n\nWorking with collections\nimport frameless.functions._\n// import frameless.functions._\n\nimport frameless.functions.nonAggregate._\n// import frameless.functions.nonAggregate._\n\nval t = cityRatio.select(cityRatio('city), lit(List(\"abc\",\"c\",\"d\")))\n// t: frameless.TypedDataset[(String, List[String])] = [_1: string, _2: array]\n\nt.withColumnTupled(\n arrayContains(t('_2), \"abc\")\n).show(1).run()\n// +-----+-----------+----+\n// | _1| _2| _3|\n// +-----+-----------+----+\n// |Paris|[abc, c, d]|true|\n// +-----+-----------+----+\n// only showing top 1 row\n//\n\nIf accidentally you apply a collection function on a column that is not a collection,\nyou get a compilation error.\nt.withColumnTupled(\n arrayContains(t('_1), \"abc\")\n)\n// :36: error: no type parameters for method arrayContains: (column: frameless.AbstractTypedColumn[T,C[A]], value: A)(implicit evidence$1: frameless.CatalystCollection[C])column.ThisType[T,Boolean] exist so that it can be applied to arguments (frameless.TypedColumn[(String, List[String]),String], String)\n// --- because ---\n// argument expression's type is not compatible with formal parameter type;\n// found : frameless.TypedColumn[(String, List[String]),String]\n// required: frameless.AbstractTypedColumn[?T,?C[?A]]\n// \n// arrayContains(t('_1), \"abc\")\n// ^\n// :36: error: type mismatch;\n// found : frameless.TypedColumn[(String, List[String]),String]\n// required: frameless.AbstractTypedColumn[T,C[A]]\n// arrayContains(t('_1), \"abc\")\n// ^\n// :36: error: type mismatch;\n// found : String(\"abc\")\n// required: A\n// arrayContains(t('_1), \"abc\")\n// ^\n// :36: error: Cannot do collection operations on columns of type C.\n// arrayContains(t('_1), \"abc\")\n// ^\n\nFlattening columns in Spark is done with the explode() method. Unlike vanilla Spark, \nin Frameless explode() is part of TypedDataset and not a function of a column. \nThis provides additional safety since more than one explode() applied in a single \nstatement results in runtime error in vanilla Spark. \nval t2 = cityRatio.select(cityRatio('city), lit(List(1,2,3,4)))\n// t2: frameless.TypedDataset[(String, List[Int])] = [_1: string, _2: array]\n\nval flattened = t2.explode('_2): TypedDataset[(String, Int)]\n// flattened: frameless.TypedDataset[(String, Int)] = [_1: string, _2: int]\n\nflattened.show(4).run()\n// +-----+---+\n// | _1| _2|\n// +-----+---+\n// |Paris| 1|\n// |Paris| 2|\n// |Paris| 3|\n// |Paris| 4|\n// +-----+---+\n// only showing top 4 rows\n//\n\nHere is an example of how explode() may fail in vanilla Spark. The Frameless \nimplementation does not suffer from this problem since, by design, it can only be applied\nto a single column at a time. \n{\n import org.apache.spark.sql.functions.{explode => sparkExplode}\n t2.dataset.toDF().select(sparkExplode($\"_2\"), sparkExplode($\"_2\"))\n}\n// org.apache.spark.sql.AnalysisException: Only one generator allowed per select clause but found 2: explode(_2), explode(_2)\n// at org.apache.spark.sql.errors.QueryCompilationErrors$.moreThanOneGeneratorError(QueryCompilationErrors.scala:95)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$$anonfun$apply$22.applyOrElse(Analyzer.scala:2510)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$$anonfun$apply$22.applyOrElse(Analyzer.scala:2503)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.$anonfun$resolveOperatorsUp$3(AnalysisHelper.scala:90)\n// at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.$anonfun$resolveOperatorsUp$1(AnalysisHelper.scala:90)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.allowInvokingTransformsInAnalyzer(AnalysisHelper.scala:221)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.resolveOperatorsUp(AnalysisHelper.scala:86)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper.resolveOperatorsUp$(AnalysisHelper.scala:84)\n// at org.apache.spark.sql.catalyst.plans.logical.LogicalPlan.resolveOperatorsUp(LogicalPlan.scala:29)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$.apply(Analyzer.scala:2503)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer$ExtractGenerator$.apply(Analyzer.scala:2447)\n// at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$2(RuleExecutor.scala:216)\n// at scala.collection.LinearSeqOptimized.foldLeft(LinearSeqOptimized.scala:126)\n// at scala.collection.LinearSeqOptimized.foldLeft$(LinearSeqOptimized.scala:122)\n// at scala.collection.immutable.List.foldLeft(List.scala:91)\n// at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$1(RuleExecutor.scala:213)\n// at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$execute$1$adapted(RuleExecutor.scala:205)\n// at scala.collection.immutable.List.foreach(List.scala:431)\n// at org.apache.spark.sql.catalyst.rules.RuleExecutor.execute(RuleExecutor.scala:205)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.org$apache$spark$sql$catalyst$analysis$Analyzer$$executeSameContext(Analyzer.scala:195)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.execute(Analyzer.scala:189)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.execute(Analyzer.scala:154)\n// at org.apache.spark.sql.catalyst.rules.RuleExecutor.$anonfun$executeAndTrack$1(RuleExecutor.scala:183)\n// at org.apache.spark.sql.catalyst.QueryPlanningTracker$.withTracker(QueryPlanningTracker.scala:88)\n// at org.apache.spark.sql.catalyst.rules.RuleExecutor.executeAndTrack(RuleExecutor.scala:183)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:173)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)\n// at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)\n// at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)\n// at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)\n// at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n// at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)\n// at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)\n// at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)\n// at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)\n// at org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:90)\n// at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n// at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:88)\n// at org.apache.spark.sql.Dataset.withPlan(Dataset.scala:3715)\n// at org.apache.spark.sql.Dataset.select(Dataset.scala:1462)\n// ... 42 elided\n\nCollecting data to the driver\nIn Frameless all Spark actions (such as collect()) are safe.\nTake the first element from a dataset (if the dataset is empty return None).\ncityBeds.headOption.run()\n// res30: Option[CityBeds] = Some(CityBeds(Paris,2))\n\nTake the first n elements.\ncityBeds.take(2).run()\n// res31: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3))\n\ncityBeds.head(3).run()\n// res32: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1))\n\ncityBeds.limit(4).collect().run()\n// res33: Seq[CityBeds] = WrappedArray(CityBeds(Paris,2), CityBeds(Paris,3), CityBeds(Paris,1), CityBeds(Lyon,2))\n\nSorting columns\nOnly column types that can be sorted are allowed to be selected for sorting. \naptTypedDs.orderBy(aptTypedDs('city).asc).show(2).run()\n// +----+-------+--------+--------+\n// |city|surface| price|bedrooms|\n// +----+-------+--------+--------+\n// |Lyon| 45|133000.0| 1|\n// |Lyon| 83|200000.0| 2|\n// +----+-------+--------+--------+\n// only showing top 2 rows\n//\n\nThe ordering can be changed by selecting .acs or .desc. \naptTypedDs.orderBy(\n aptTypedDs('city).asc, \n aptTypedDs('price).desc\n).show(2).run()\n// +----+-------+--------+--------+\n// |city|surface| price|bedrooms|\n// +----+-------+--------+--------+\n// |Lyon| 83|200000.0| 2|\n// |Lyon| 45|133000.0| 1|\n// +----+-------+--------+--------+\n// only showing top 2 rows\n//\n\nUser Defined Functions\nFrameless supports lifting any Scala function (up to five arguments) to the\ncontext of a particular TypedDataset:\n// The function we want to use as UDF\nval priceModifier =\n (name: String, price:Double) => if(name == \"Paris\") price * 2.0 else price\n// priceModifier: (String, Double) => Double = \n\nval udf = aptTypedDs.makeUDF(priceModifier)\n// udf: (frameless.TypedColumn[Apartment,String], frameless.TypedColumn[Apartment,Double]) => frameless.TypedColumn[Apartment,Double] = frameless.functions.Udf$$Lambda$12549/0x0000000803898840@61521397\n\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval adjustedPrice = aptds.select(aptds('city), udf(aptds('city), aptds('price)))\n// adjustedPrice: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\nadjustedPrice.show().run()\n// +-----+--------+\n// | _1| _2|\n// +-----+--------+\n// |Paris|600000.0|\n// |Paris|900000.0|\n// |Paris|500000.0|\n// | Lyon|200000.0|\n// | Lyon|133000.0|\n// | Nice|325000.0|\n// +-----+--------+\n//\n\nGroupBy and Aggregations\nLet's suppose we wanted to retrieve the average apartment price in each city\nval priceByCity = aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('price)))\n// priceByCity: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\npriceByCity.collect().run()\n// res38: Seq[(String, Double)] = WrappedArray((Nice,325000.0), (Paris,333333.3333333333), (Lyon,166500.0))\n\nAgain if we try to aggregate a column that can't be aggregated, we get a compilation error\naptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))\n// :35: error: Cannot compute average of type String.\n// aptTypedDs.groupBy(aptTypedDs('city)).agg(avg(aptTypedDs('city)))\n// ^\n\nNext, we combine select and groupBy to calculate the average price/surface ratio per city:\nval aptds = aptTypedDs // For shorter expressions\n// aptds: frameless.TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields]\n\nval cityPriceRatio = aptds.select(aptds('city), aptds('price) / aptds('surface).cast[Double])\n// cityPriceRatio: frameless.TypedDataset[(String, Double)] = [_1: string, _2: double]\n\ncityPriceRatio.groupBy(cityPriceRatio('_1)).agg(avg(cityPriceRatio('_2))).show().run()\n// +-----+------------------+\n// | _1| _2|\n// +-----+------------------+\n// | Nice| 4391.891891891892|\n// |Paris| 6833.333333333333|\n// | Lyon|2682.5970548862115|\n// +-----+------------------+\n//\n\nWe can also use pivot to further group data on a secondary column.\nFor example, we can compare the average price across cities by number of bedrooms.\ncase class BedroomStats(\n city: String,\n AvgPriceBeds1: Option[Double], // Pivot values may be missing, so we encode them using Options\n AvgPriceBeds2: Option[Double],\n AvgPriceBeds3: Option[Double],\n AvgPriceBeds4: Option[Double])\n// defined class BedroomStats\n\nval bedroomStats = aptds.\n groupBy(aptds('city)).\n pivot(aptds('bedrooms)).\n on(1,2,3,4). // We only care for up to 4 bedrooms\n agg(avg(aptds('price))).\n as[BedroomStats] // Typesafe casting\n// bedroomStats: frameless.TypedDataset[BedroomStats] = [city: string, AvgPriceBeds1: double ... 3 more fields]\n\nbedroomStats.show().run()\n// +-----+-------------+-------------+-------------+-------------+\n// | city|AvgPriceBeds1|AvgPriceBeds2|AvgPriceBeds3|AvgPriceBeds4|\n// +-----+-------------+-------------+-------------+-------------+\n// | Nice| null| null| 325000.0| null|\n// |Paris| 250000.0| 300000.0| 450000.0| null|\n// | Lyon| 133000.0| 200000.0| null| null|\n// +-----+-------------+-------------+-------------+-------------+\n//\n\nWith pivot, collecting data preserves typesafety by\nencoding potentially missing columns with Option.\nbedroomStats.collect().run().foreach(println)\n// BedroomStats(Nice,None,None,Some(325000.0),None)\n// BedroomStats(Paris,Some(250000.0),Some(300000.0),Some(450000.0),None)\n// BedroomStats(Lyon,Some(133000.0),Some(200000.0),None,None)\n\nWorking with Optional fields\nOptional fields can be converted to non-optional using getOrElse(). \nval sampleStats = bedroomStats.select(\n bedroomStats('AvgPriceBeds2).getOrElse(0.0),\n bedroomStats('AvgPriceBeds3).getOrElse(0.0))\n// sampleStats: frameless.TypedDataset[(Double, Double)] = [_1: double, _2: double]\n\nsampleStats.show().run() \n// +--------+--------+\n// | _1| _2|\n// +--------+--------+\n// | 0.0|325000.0|\n// |300000.0|450000.0|\n// |200000.0| 0.0|\n// +--------+--------+\n//\n\nIn addition, optional columns can be flatten using the .flattenOption method on TypedDatset.\nThe result contains the rows for which the flattened column is not None (or null). The schema\nis automatically adapted to reflect this change.\nval flattenStats = bedroomStats.flattenOption('AvgPriceBeds2)\n// flattenStats: frameless.TypedDataset[this.Out] = [_1: string, _2: double ... 3 more fields]\n\n// The second Option[Double] is now of type Double, since all 'null' values are removed\nflattenStats: TypedDataset[(String, Option[Double], Double, Option[Double], Option[Double])]\n// res45: frameless.TypedDataset[(String, Option[Double], Double, Option[Double], Option[Double])] = [_1: string, _2: double ... 3 more fields]\n\nIn a DataFrame, if you just ignore types, this would equivelantly be written as:\nbedroomStats.dataset.toDF().filter($\"AvgPriceBeds2\".isNotNull)\n// res46: org.apache.spark.sql.Dataset[org.apache.spark.sql.Row] = [city: string, AvgPriceBeds1: double ... 3 more fields]\n\nEntire TypedDataset Aggregation\nWe often want to aggregate the entire TypedDataset and skip the groupBy() clause.\nIn Frameless you can do this using the agg() operator directly on the TypedDataset.\nIn the following example, we compute the average price, the average surface,\nthe minimum surface, and the set of cities for the entire dataset.\ncase class Stats(\n avgPrice: Double,\n avgSurface: Double,\n minSurface: Int,\n allCities: Vector[String])\n// defined class Stats\n\naptds.agg(\n avg(aptds('price)),\n avg(aptds('surface)),\n min(aptds('surface)),\n collectSet(aptds('city))\n).as[Stats].show().run()\n// +-----------------+------------------+----------+-------------------+\n// | avgPrice| avgSurface|minSurface| allCities|\n// +-----------------+------------------+----------+-------------------+\n// |276333.3333333333|62.833333333333336| 25|[Paris, Nice, Lyon]|\n// +-----------------+------------------+----------+-------------------+\n//\n\nYou may apply any TypedColumn operation to a TypedAggregate column as well.\nimport frameless.functions._\n// import frameless.functions._\n\naptds.agg(\n avg(aptds('price)) * min(aptds('surface)).cast[Double], \n avg(aptds('surface)) * 0.2,\n litAggr(\"Hello World\")\n).show().run()\n// +-----------------+------------------+-----------+\n// | _1| _2| _3|\n// +-----------------+------------------+-----------+\n// |6908333.333333333|12.566666666666668|Hello World|\n// +-----------------+------------------+-----------+\n//\n\nJoins\ncase class CityPopulationInfo(name: String, population: Int)\n\nval cityInfo = Seq(\n CityPopulationInfo(\"Paris\", 2229621),\n CityPopulationInfo(\"Lyon\", 500715),\n CityPopulationInfo(\"Nice\", 343629)\n)\n\nval citiInfoTypedDS = TypedDataset.create(cityInfo)\n\nHere is how to join the population information to the apartment's dataset:\nval withCityInfo = aptTypedDs.joinInner(citiInfoTypedDS) { aptTypedDs('city) === citiInfoTypedDS('name) }\n// withCityInfo: frameless.TypedDataset[(Apartment, CityPopulationInfo)] = [_1: struct, _2: struct]\n\nwithCityInfo.show().run()\n// +--------------------+----------------+\n// | _1| _2|\n// +--------------------+----------------+\n// |{Paris, 50, 30000...|{Paris, 2229621}|\n// |{Paris, 100, 4500...|{Paris, 2229621}|\n// |{Paris, 25, 25000...|{Paris, 2229621}|\n// |{Lyon, 83, 200000...| {Lyon, 500715}|\n// |{Lyon, 45, 133000...| {Lyon, 500715}|\n// |{Nice, 74, 325000...| {Nice, 343629}|\n// +--------------------+----------------+\n//\n\nThe joined TypedDataset has type TypedDataset[(Apartment, CityPopulationInfo)].\nWe can then select which information we want to continue to work with:\ncase class AptPriceCity(city: String, aptPrice: Double, cityPopulation: Int)\n// defined class AptPriceCity\n\nwithCityInfo.select(\n withCityInfo.colMany('_2, 'name), withCityInfo.colMany('_1, 'price), withCityInfo.colMany('_2, 'population)\n).as[AptPriceCity].show().run\n// +-----+--------+--------------+\n// | city|aptPrice|cityPopulation|\n// +-----+--------+--------------+\n// |Paris|300000.0| 2229621|\n// |Paris|450000.0| 2229621|\n// |Paris|250000.0| 2229621|\n// | Lyon|200000.0| 500715|\n// | Lyon|133000.0| 500715|\n// | Nice|325000.0| 343629|\n// +-----+--------+--------------+\n//\n\n"},"TypedDatasetVsSparkDataset.html":{"url":"TypedDatasetVsSparkDataset.html","title":"Comparing TypedDatasets with Spark's Datasets","keywords":"","body":"Comparing TypedDatasets with Spark's Datasets\nGoal:\n This tutorial compares the standard Spark Datasets API with the one provided by\n Frameless' TypedDataset. It shows how TypedDatasets allow for an expressive and\n type-safe api with no compromises on performance.\nFor this tutorial we first create a simple dataset and save it on disk as a parquet file.\nParquet is a popular columnar format and well supported by Spark.\nIt's important to note that when operating on parquet datasets, Spark knows that each column is stored\nseparately, so if we only need a subset of the columns Spark will optimize for this and avoid reading\nthe entire dataset. This is a rather simplistic view of how Spark and parquet work together but it\nwill serve us well for the context of this discussion.\nimport spark.implicits._\n// import spark.implicits._\n\n// Our example case class Foo acting here as a schema\ncase class Foo(i: Long, j: String)\n// defined class Foo\n\n// Assuming spark is loaded and SparkSession is bind to spark\nval initialDs = spark.createDataset( Foo(1, \"Q\") :: Foo(10, \"W\") :: Foo(100, \"E\") :: Nil )\n// initialDs: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\n// Assuming you are on Linux or Mac OS\ninitialDs.write.parquet(\"/tmp/foo\")\n\nval ds = spark.read.parquet(\"/tmp/foo\").as[Foo]\n// ds: org.apache.spark.sql.Dataset[Foo] = [i: bigint, j: string]\n\nds.show()\n// +---+---+\n// | i| j|\n// +---+---+\n// |100| E|\n// | 10| W|\n// | 1| Q|\n// +---+---+\n//\n\nThe value ds holds the content of the initialDs read from a parquet file.\nLet's try to only use field i from Foo and see how Spark's Catalyst (the query optimizer)\noptimizes this.\n// Using a standard Spark TypedColumn in select()\nval filteredDs = ds.filter($\"i\" === 10).select($\"i\".as[Long])\n// filteredDs: org.apache.spark.sql.Dataset[Long] = [i: bigint]\n\nfilteredDs.show()\n// +---+\n// | i|\n// +---+\n// | 10|\n// +---+\n//\n\nThe filteredDs is of type Dataset[Long]. Since we only access field i from Foo the type is correct.\nUnfortunately, this syntax requires handholding by explicitly setting the TypedColumn in the select statement\nto return type Long (look at the as[Long] statement). We will discuss this limitation next in more detail.\nNow, let's take a quick look at the optimized Physical Plan that Spark's Catalyst generated.\nfilteredDs.explain()\n// == Physical Plan ==\n// *(1) Filter (isnotnull(i#23L) AND (i#23L = 10))\n// +- *(1) ColumnarToRow\n// +- FileScan parquet [i#23L] Batched: true, DataFilters: [isnotnull(i#23L), (i#23L = 10)], Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n// \n//\n\nThe last line is very important (see ReadSchema). The schema read\nfrom the parquet file only required reading column i without needing to access column j.\nThis is great! We have both an optimized query plan and type-safety!\nUnfortunately, this syntax is not bulletproof: it fails at run-time if we try to access\na non existing column x:\nscala> ds.filter($\"i\" === 10).select($\"x\".as[Long])\norg.apache.spark.sql.AnalysisException: cannot resolve '`x`' given input columns: [i, j];\n'Project ['x]\n+- Filter (i#23L = cast(10 as bigint))\n +- Relation[i#23L,j#24] parquet\n\n at org.apache.spark.sql.catalyst.analysis.package$AnalysisErrorAt.failAnalysis(package.scala:42)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:155)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis$$anonfun$$nestedInanonfun$checkAnalysis$1$2.applyOrElse(CheckAnalysis.scala:152)\n at org.apache.spark.sql.catalyst.trees.TreeNode.$anonfun$transformUp$2(TreeNode.scala:341)\n at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)\n at org.apache.spark.sql.catalyst.trees.TreeNode.transformUp(TreeNode.scala:341)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$transformExpressionsUp$1(QueryPlan.scala:104)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$1(QueryPlan.scala:116)\n at org.apache.spark.sql.catalyst.trees.CurrentOrigin$.withOrigin(TreeNode.scala:73)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpression$1(QueryPlan.scala:116)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:127)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$3(QueryPlan.scala:132)\n at scala.collection.TraversableLike.$anonfun$map$1(TraversableLike.scala:285)\n at scala.collection.immutable.List.foreach(List.scala:431)\n at scala.collection.TraversableLike.map(TraversableLike.scala:285)\n at scala.collection.TraversableLike.map$(TraversableLike.scala:278)\n at scala.collection.immutable.List.map(List.scala:305)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.recursiveTransform$1(QueryPlan.scala:132)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.$anonfun$mapExpressions$4(QueryPlan.scala:137)\n at org.apache.spark.sql.catalyst.trees.TreeNode.mapProductIterator(TreeNode.scala:243)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.mapExpressions(QueryPlan.scala:137)\n at org.apache.spark.sql.catalyst.plans.QueryPlan.transformExpressionsUp(QueryPlan.scala:104)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1(CheckAnalysis.scala:152)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1$adapted(CheckAnalysis.scala:93)\n at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:183)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:93)\n at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:90)\n at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:154)\n at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:175)\n at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)\n at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)\n at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)\n at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)\n at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)\n at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)\n at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)\n at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)\n at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)\n at org.apache.spark.sql.Dataset.(Dataset.scala:210)\n at org.apache.spark.sql.Dataset.(Dataset.scala:216)\n at org.apache.spark.sql.Dataset.select(Dataset.scala:1517)\n ... 42 elided\n\nThere are two things to improve here. First, we would want to avoid the as[Long] casting that we are required\nto type for type-safety. This is clearly an area where we may introduce a bug by casting to an incompatible\ntype. Second, we want a solution where reference to a non existing column name fails at compilation time.\nThe standard Spark Dataset can achieve this using the following syntax.\nds.filter(_.i == 10).map(_.i).show()\n// +-----+\n// |value|\n// +-----+\n// | 10|\n// +-----+\n//\n\nThis looks great! It reminds us the familiar syntax from Scala.\nThe two closures in filter and map are functions that operate on Foo and the\ncompiler will helps us capture all the mistakes we mentioned above.\nscala> ds.filter(_.i == 10).map(_.x).show()\n:20: error: value x is not a member of Foo\n ds.filter(_.i == 10).map(_.x).show()\n ^\n\nUnfortunately, this syntax does not allow Spark to optimize the code.\nds.filter(_.i == 10).map(_.i).explain()\n// == Physical Plan ==\n// *(1) SerializeFromObject [input[0, bigint, false] AS value#74L]\n// +- *(1) MapElements , obj#73: bigint\n// +- *(1) Filter .apply\n// +- *(1) DeserializeToObject newInstance(class $line14.$read$$iw$$iw$$iw$$iw$Foo), obj#72: $line14.$read$$iw$$iw$$iw$$iw$Foo\n// +- *(1) ColumnarToRow\n// +- FileScan parquet [i#23L,j#24] Batched: true, DataFilters: [], Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [], ReadSchema: struct\n// \n//\n\nAs we see from the explained Physical Plan, Spark was not able to optimize our query as before.\nReading the parquet file will required loading all the fields of Foo. This might be ok for\nsmall datasets or for datasets with few columns, but will be extremely slow for most practical\napplications. Intuitively, Spark currently does not have a way to look inside the code we pass in these two\nclosures. It only knows that they both take one argument of type Foo, but it has no way of knowing if\nwe use just one or all of Foo's fields.\nThe TypedDataset in Frameless solves this problem. It allows for a simple and type-safe syntax\nwith a fully optimized query plan.\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport frameless.syntax._\n// import frameless.syntax._\n\nval fds = TypedDataset.create(ds)\n// fds: frameless.TypedDataset[Foo] = [i: bigint, j: string]\n\nfds.filter(fds('i) === 10).select(fds('i)).show().run()\n// +-----+\n// |value|\n// +-----+\n// | 10|\n// +-----+\n//\n\nAnd the optimized Physical Plan:\nfds.filter(fds('i) === 10).select(fds('i)).explain()\n// == Physical Plan ==\n// *(1) Project [i#23L AS value#158L]\n// +- *(1) Filter (isnotnull(i#23L) AND (i#23L = 10))\n// +- *(1) ColumnarToRow\n// +- FileScan parquet [i#23L] Batched: true, DataFilters: [isnotnull(i#23L), (i#23L = 10)], Format: Parquet, Location: InMemoryFileIndex[file:/tmp/foo], PartitionFilters: [], PushedFilters: [IsNotNull(i), EqualTo(i,10)], ReadSchema: struct\n// \n//\n\nAnd the compiler is our friend.\nscala> fds.filter(fds('i) === 10).select(fds('x))\n:24: error: No column Symbol with shapeless.tag.Tagged[String(\"x\")] of type A in Foo\n fds.filter(fds('i) === 10).select(fds('x))\n ^\n\nDifferences in Encoders\nEncoders in Spark's Datasets are partially type-safe. If you try to create a Dataset using a type that is not \n a Scala Product then you get a compilation error:\nclass Bar(i: Int)\n// defined class Bar\n\nBar is neither a case class nor a Product, so the following correctly gives a compilation error in Spark:\nscala> spark.createDataset(Seq(new Bar(1)))\n:24: error: Unable to find encoder for type Bar. An implicit Encoder[Bar] is needed to store Bar instances in a Dataset. Primitive types (Int, String, etc) and Product types (case classes) are supported by importing spark.implicits._ Support for serializing other types will be added in future releases.\n spark.createDataset(Seq(new Bar(1)))\n ^\n\nHowever, the compile type guards implemented in Spark are not sufficient to detect non encodable members. \nFor example, using the following case class leads to a runtime failure:\ncase class MyDate(jday: java.util.Date)\n// defined class MyDate\n\nval myDateDs = spark.createDataset(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// java.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n// - field (class: \"java.util.Date\", name: \"jday\")\n// - root class: \"MyDate\"\n// at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:591)\n// at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)\n// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)\n// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$6(ScalaReflection.scala:577)\n// at scala.collection.immutable.List.map(List.scala:293)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:562)\n// at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)\n// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)\n// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerForType$1(ScalaReflection.scala:421)\n// at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)\n// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)\n// at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)\n// at org.apache.spark.sql.catalyst.ScalaReflection$.serializerForType(ScalaReflection.scala:413)\n// at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:56)\n// at org.apache.spark.sql.Encoders$.product(Encoders.scala:285)\n// at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder(SQLImplicits.scala:251)\n// at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder$(SQLImplicits.scala:251)\n// at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:32)\n// ... 42 elided\n\nIn comparison, a TypedDataset will notify about the encoding problem at compile time: \nTypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// :25: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[MyDate]\n// TypedDataset.create(Seq(MyDate(new java.util.Date(System.currentTimeMillis))))\n// ^\n\nAggregate vs Projected columns\nSpark's Dataset do not distinguish between columns created from aggregate operations, \nsuch as summing or averaging, and simple projections/selections. \nThis is problematic when you start mixing the two.\nimport org.apache.spark.sql.functions.sum\n// import org.apache.spark.sql.functions.sum\n\nds.select(sum($\"i\"), $\"i\"*2)\n// org.apache.spark.sql.AnalysisException: grouping expressions sequence is empty, and '`i`' is not an aggregate function. Wrap '(sum(`i`) AS `sum(i)`)' in windowing function(s) or wrap '`i`' in first() (or first_value) if you don't care which value you get.;\n// Aggregate [sum(i#23L) AS sum(i)#164L, (i#23L * cast(2 as bigint)) AS (i * 2)#165L]\n// +- Relation[i#23L,j#24] parquet\n// \n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.failAnalysis(CheckAnalysis.scala:50)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.failAnalysis$(CheckAnalysis.scala:49)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.failAnalysis(Analyzer.scala:154)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkValidAggregateExpression$1(CheckAnalysis.scala:263)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$12(CheckAnalysis.scala:272)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$12$adapted(CheckAnalysis.scala:272)\n// at scala.collection.immutable.List.foreach(List.scala:431)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkValidAggregateExpression$1(CheckAnalysis.scala:272)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$12(CheckAnalysis.scala:272)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$12$adapted(CheckAnalysis.scala:272)\n// at scala.collection.immutable.List.foreach(List.scala:431)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkValidAggregateExpression$1(CheckAnalysis.scala:272)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$15(CheckAnalysis.scala:299)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$15$adapted(CheckAnalysis.scala:299)\n// at scala.collection.mutable.ResizableArray.foreach(ResizableArray.scala:62)\n// at scala.collection.mutable.ResizableArray.foreach$(ResizableArray.scala:55)\n// at scala.collection.mutable.ArrayBuffer.foreach(ArrayBuffer.scala:49)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1(CheckAnalysis.scala:299)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$1$adapted(CheckAnalysis.scala:93)\n// at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:183)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:93)\n// at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:90)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:154)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:175)\n// at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:228)\n// at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:172)\n// at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:73)\n// at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111)\n// at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:143)\n// at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n// at org.apache.spark.sql.execution.QueryExecution.executePhase(QueryExecution.scala:143)\n// at org.apache.spark.sql.execution.QueryExecution.analyzed$lzycompute(QueryExecution.scala:73)\n// at org.apache.spark.sql.execution.QueryExecution.analyzed(QueryExecution.scala:71)\n// at org.apache.spark.sql.execution.QueryExecution.assertAnalyzed(QueryExecution.scala:63)\n// at org.apache.spark.sql.Dataset$.$anonfun$ofRows$1(Dataset.scala:90)\n// at org.apache.spark.sql.SparkSession.withActive(SparkSession.scala:772)\n// at org.apache.spark.sql.Dataset$.ofRows(Dataset.scala:88)\n// at org.apache.spark.sql.Dataset.withPlan(Dataset.scala:3715)\n// at org.apache.spark.sql.Dataset.select(Dataset.scala:1462)\n// ... 42 elided\n\nIn Frameless, mixing the two results in a compilation error.\n// To avoid confusing frameless' sum with the standard Spark's sum\nimport frameless.functions.aggregate.{sum => fsum}\n// import frameless.functions.aggregate.{sum=>fsum}\n\nfds.select(fsum(fds('i)))\n// :26: error: polymorphic expression cannot be instantiated to expected type;\n// found : [Out]frameless.TypedAggregate[Foo,Out]\n// required: frameless.TypedColumn[Foo,?]\n// fds.select(fsum(fds('i)))\n// ^\n\nAs the error suggests, we expected a TypedColumn but we got a TypedAggregate instead. \nHere is how you apply an aggregation method in Frameless: \nfds.agg(fsum(fds('i))+22).show().run()\n// +-----+\n// |value|\n// +-----+\n// | 133|\n// +-----+\n//\n\nSimilarly, mixing projections while aggregating does not make sense, and in Frameless\nyou get a compilation error. \nfds.agg(fsum(fds('i)), fds('i)).show().run()\n// :26: error: polymorphic expression cannot be instantiated to expected type;\n// found : [A]frameless.TypedColumn[Foo,A]\n// required: frameless.TypedAggregate[Foo,?]\n// fds.agg(fsum(fds('i)), fds('i)).show().run()\n// ^\n\n"},"TypedEncoder.html":{"url":"TypedEncoder.html","title":"Typed Encoders in Frameless","keywords":"","body":"Typed Encoders in Frameless\nSpark uses Reflection to derive its Encoders, which is why they can fail at run time. For example, because Spark does not support java.util.Date, the following leads to an error:\nimport org.apache.spark.sql.Dataset\nimport spark.implicits._\n\ncase class DateRange(s: java.util.Date, e: java.util.Date)\n\nscala> val ds: Dataset[DateRange] = Seq(DateRange(new java.util.Date, new java.util.Date)).toDS()\njava.lang.UnsupportedOperationException: No Encoder found for java.util.Date\n- field (class: \"java.util.Date\", name: \"s\")\n- root class: \"DateRange\"\n at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:591)\n at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)\n at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)\n at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)\n at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)\n at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432)\n at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$6(ScalaReflection.scala:577)\n at scala.collection.immutable.List.map(List.scala:293)\n at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerFor$1(ScalaReflection.scala:562)\n at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)\n at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)\n at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)\n at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)\n at org.apache.spark.sql.catalyst.ScalaReflection$.serializerFor(ScalaReflection.scala:432)\n at org.apache.spark.sql.catalyst.ScalaReflection$.$anonfun$serializerForType$1(ScalaReflection.scala:421)\n at scala.reflect.internal.tpe.TypeConstraints$UndoLog.undo(TypeConstraints.scala:73)\n at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects(ScalaReflection.scala:904)\n at org.apache.spark.sql.catalyst.ScalaReflection.cleanUpReflectionObjects$(ScalaReflection.scala:903)\n at org.apache.spark.sql.catalyst.ScalaReflection$.cleanUpReflectionObjects(ScalaReflection.scala:49)\n at org.apache.spark.sql.catalyst.ScalaReflection$.serializerForType(ScalaReflection.scala:413)\n at org.apache.spark.sql.catalyst.encoders.ExpressionEncoder$.apply(ExpressionEncoder.scala:56)\n at org.apache.spark.sql.Encoders$.product(Encoders.scala:285)\n at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder(SQLImplicits.scala:251)\n at org.apache.spark.sql.LowPrioritySQLImplicits.newProductEncoder$(SQLImplicits.scala:251)\n at org.apache.spark.sql.SQLImplicits.newProductEncoder(SQLImplicits.scala:32)\n ... 42 elided\n\nAs shown by the stack trace, this runtime error goes through ScalaReflection to try to derive an Encoder for Dataset schema. Beside the annoyance of not detecting this error at compile time, a more important limitation of the reflection-based approach is its inability to be extended for custom types. See this Stack Overflow question for a summary of the current situation (as of 2.0) in vanilla Spark: How to store custom objects in a Dataset?.\nFrameless introduces a new type class called TypeEncoder to solve these issues. TypeEncoders are passed around as implicit parameters to every Frameless method to ensure that the data being manipulated is Encoder. It uses a standard implicit resolution coupled with shapeless' type class derivation mechanism to ensure every that compiling code manipulates encodable data. For example, the java.util.Date example won't compile with Frameless:\nimport frameless.TypedDataset\nimport frameless.syntax._\n\nval ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// :28: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[DateRange]\n// val ds: TypedDataset[DateRange] = TypedDataset.create(Seq(DateRange(new java.util.Date, new java.util.Date)))\n// ^\n\nType class derivation takes care of recursively constructing (and proving the existence of) TypeEncoders for case classes. The following works as expected:\ncase class Bar(d: Double, s: String)\n// defined class Bar\n\ncase class Foo(i: Int, b: Bar)\n// defined class Foo\n\nval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, \"s\"))))\n// ds: frameless.TypedDataset[Foo] = [i: int, b: struct]\n\nds.collect()\n// res1: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@77bca0d3\n\nBut any non-encodable in the case class hierarchy will be detected at compile time:\ncase class BarDate(d: Double, s: String, t: java.util.Date)\ncase class FooDate(i: Int, b: BarDate)\n\nval ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// :30: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[FooDate]\n// val ds: TypedDataset[FooDate] = TypedDataset.create(Seq(FooDate(1, BarDate(1.1, \"s\", new java.util.Date))))\n// ^\n\nIt should be noted that once derived, reflection-based Encoders and implicitly derived TypeEncoders have identical performance. The derivation mechanism is different, but the objects generated to encode and decode JVM objects in Spark's internal representation behave the same at runtime.\n"},"Injection.html":{"url":"Injection.html","title":"Injection: Creating Custom Encoders","keywords":"","body":"Injection: Creating Custom Encoders\nInjection lets us define encoders for types that do not have one by injecting A into an encodable type B.\nThis is the definition of the injection typeclass:\ntrait Injection[A, B] extends Serializable {\n def apply(a: A): B\n def invert(b: B): A\n}\n\nExample\nLet's define a simple case class:\ncase class Person(age: Int, birthday: java.util.Date)\n// defined class Person\n\nval people = Seq(Person(42, new java.util.Date))\n// people: Seq[Person] = List(Person(42,Tue Jan 19 20:29:11 PST 2021))\n\nAnd an instance of a TypedDataset:\nval personDS = TypedDataset.create(people)\n// :23: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n// val personDS = TypedDataset.create(people)\n// ^\n\nLooks like we can't, a TypedEncoder instance of Person is not available, or more precisely for java.util.Date.\nBut we can define a injection from java.util.Date to an encodable type, like Long:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = new Injection[java.util.Date, Long] {\n def apply(d: java.util.Date): Long = d.getTime()\n def invert(l: Long): java.util.Date = new java.util.Date(l)\n}\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = $anon$1@17559031\n\nWe can be less verbose using the Injection.apply function:\nimport frameless._\n// import frameless._\n\nimplicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))\n// dateToLongInjection: frameless.Injection[java.util.Date,Long] = frameless.Injection$$anon$1@7d716477\n\nNow we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, birthday: bigint]\n\nAnother example\nLet's define a sealed family:\nsealed trait Gender\n// defined trait Gender\n\ncase object Male extends Gender\n// defined object Male\n\ncase object Female extends Gender\n// defined object Female\n\ncase object Other extends Gender\n// defined object Other\n\nAnd a simple case class:\ncase class Person(age: Int, gender: Gender)\n// defined class Person\n\nval people = Seq(Person(42, Male))\n// people: Seq[Person] = List(Person(42,Male))\n\nAgain if we try to create a TypedDataset, we get a compilation error.\nval personDS = TypedDataset.create(people)\n// :31: error: could not find implicit value for parameter encoder: frameless.TypedEncoder[Person]\n// val personDS = TypedDataset.create(people)\n// ^\n\nLet's define an injection instance for Gender:\nimplicit val genderToInt: Injection[Gender, Int] = Injection(\n {\n case Male => 1\n case Female => 2\n case Other => 3\n },\n {\n case 1 => Male\n case 2 => Female\n case 3 => Other\n })\n// :35: warning: match may not be exhaustive.\n// It would fail on the following inputs: Female, Male, Other\n// {\n// ^\n// genderToInt: frameless.Injection[Gender,Int] = frameless.Injection$$anon$1@7c0fbe02\n\nAnd now we can create our TypedDataset:\nval personDS = TypedDataset.create(people)\n// personDS: frameless.TypedDataset[Person] = [age: int, gender: int]\n\n"},"Job.html":{"url":"Job.html","title":"Job[A]","keywords":"","body":"Job[A]\nAll operations on TypedDataset are lazy. An operation either returns a new\ntransformed TypedDataset or an F[A], where F[_] is a type constructor\nwith an instance of the SparkDelay typeclass and A is the result of running a\nnon-lazy computation in Spark. \nA default such type constructor called Job is provided by Frameless. \nJob serves several functions:\n\nMakes all operations on a TypedDataset lazy, which makes them more predictable compared to having\nfew operations being lazy and other being strict\nAllows the programmer to make expensive blocking operations explicit\nAllows for Spark jobs to be lazily sequenced using monadic composition via for-comprehension\nProvides an obvious place where you can annotate/name your Spark jobs to make it easier\nto track different parts of your application in the Spark UI\n\nThe toy example showcases the use of for-comprehension to explicitly sequences Spark Jobs.\nFirst we calculate the size of the TypedDataset and then we collect to the driver\nexactly 20% of its elements:\nimport frameless.syntax._\n// import frameless.syntax._\n\nval ds = TypedDataset.create(1 to 20)\n// ds: frameless.TypedDataset[Int] = [value: int]\n\nval countAndTakeJob =\n for {\n count \nThe countAndTakeJob can either be executed using run() (as we show above) or it can\nbe passed along to other parts of the program to be further composed into more complex sequences\nof Spark jobs.\nimport frameless.Job\n// import frameless.Job\n\ndef computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min)\n// computeMinOfSample: (sample: frameless.Job[Seq[Int]])frameless.Job[Int]\n\nval finalJob = computeMinOfSample(countAndTakeJob)\n// finalJob: frameless.Job[Int] = frameless.Job$$anon$2@123416f3\n\nNow we can execute this new job by specifying a group-id and a description.\nThis allows the programmer to see this information on the Spark UI and help track, say,\nperformance issues.\nfinalJob.\n withGroupId(\"samplingJob\").\n withDescription(\"Samples 20% of elements and computes the min\").\n run()\n// res2: Int = 1\n\nMore on SparkDelay\nAs mentioned above, SparkDelay[F[_]] is a typeclass required for suspending\neffects by Spark computations. This typeclass represents the ability to suspend\nan => A thunk into an F[A] value, while implicitly capturing a SparkSession.\nAs it is a typeclass, it is open for implementation by the user in order to use\nother data types for suspension of effects. The cats module, for example, uses\nthis typeclass to support suspending Spark computations in any effect type that\nhas a cats.effect.Sync instance.\n"},"Cats.html":{"url":"Cats.html","title":"Using Cats with RDDs","keywords":"","body":"Using Cats with Frameless\nThere are two main parts to the cats integration offered by Frameless:\n\neffect suspension in TypedDataset using cats-effect and cats-mtl\nRDD enhancements using algebraic typeclasses in cats-kernel\n\nAll the examples below assume you have previously imported cats.implicits and frameless.cats.implicits.\nNote that you should not import frameless.syntax._ together with frameless.cats.implicits._.\nimport cats.implicits._\n// import cats.implicits._\n\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nEffect Suspension in typed datasets\nAs noted in the section about Job, all operations on TypedDataset are lazy. The results of \noperations that would normally block on plain Spark APIs are wrapped in a type constructor F[_], \nfor which there exists an instance of SparkDelay[F]. This typeclass represents the operation of \ndelaying a computation and capturing an implicit SparkSession. \nIn the cats module, we utilize the typeclasses from cats-effect for abstracting over these \neffect types - namely, we provide an implicit SparkDelay instance for all F[_] for which exists\nan instance of cats.effect.Sync[F].\nThis allows one to run operations on TypedDataset in an existing monad stack. For example, given\nthis pre-existing monad stack:\nimport frameless.TypedDataset\n// import frameless.TypedDataset\n\nimport cats.data.ReaderT\n// import cats.data.ReaderT\n\nimport cats.effect.IO\n// import cats.effect.IO\n\nimport cats.effect.implicits._\n// import cats.effect.implicits._\n\ntype Action[T] = ReaderT[IO, SparkSession, T]\n// defined type alias Action\n\nWe will be able to request that values from TypedDataset will be suspended in this stack:\nval typedDs = TypedDataset.create(Seq((1, \"string\"), (2, \"another\")))\n// typedDs: frameless.TypedDataset[(Int, String)] = [_1: int, _2: string]\n\nval result: Action[(Seq[(Int, String)], Long)] = for {\n sample \nAs with Job, note that nothing has been run yet. The effect has been properly suspended. To\nrun our program, we must first supply the SparkSession to the ReaderT layer and then\nrun the IO effect:\nresult.run(spark).unsafeRunSync()\n// res5: (Seq[(Int, String)], Long) = (WrappedArray((1,string)),2)\n\nConvenience methods for modifying Spark thread-local variables\nThe frameless.cats.implicits._ import also provides some syntax enrichments for any monad\nstack that has the same capabilities as Action above. Namely, the ability to provide an\ninstance of SparkSession and the ability to suspend effects.\nFor these to work, we will need to import the implicit machinery from the cats-mtl library:\nimport cats.mtl.implicits._\n// import cats.mtl.implicits._\n\nAnd now, we can set the description for the computation being run:\nval resultWithDescription: Action[(Seq[(Int, String)], Long)] = for {\n r \nUsing algebraic typeclasses from Cats with RDDs\nData aggregation is one of the most important operations when working with Spark (and data in general).\nFor example, we often have to compute the min, max, avg, etc. from a set of columns grouped by\ndifferent predicates. This section shows how cats simplifies these tasks in Spark by\nleveraging a large collection of Type Classes for ordering and aggregating data.\nCats offers ways to sort and aggregate tuples of arbitrary arity.\nimport frameless.cats.implicits._\n// import frameless.cats.implicits._\n\nval data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = ParallelCollectionRDD[12] at makeRDD at :43\n\nprintln(data.csum)\n// (10,9,9)\n\nprintln(data.cmax)\n// (8,2,3)\n\nprintln(data.cmin)\n// (1,2,3)\n\nIn case the RDD is empty, the csum, cmax and cmin will use the default values for the type of\nelements inside the RDD. There are counterpart operations to those that have an Option return type\nto deal with the case of an empty RDD:\nval data: RDD[(Int, Int, Int)] = sc.emptyRDD\n// data: org.apache.spark.rdd.RDD[(Int, Int, Int)] = EmptyRDD[13] at emptyRDD at :43\n\nprintln(data.csum)\n// (0,0,0)\n\nprintln(data.csumOption)\n// None\n\nprintln(data.cmax)\n// (0,0,0)\n\nprintln(data.cmaxOption)\n// None\n\nprintln(data.cmin)\n// (0,0,0)\n\nprintln(data.cminOption)\n// None\n\nThe following example aggregates all the elements with a common key.\ntype User = String\n// defined type alias User\n\ntype TransactionCount = Int\n// defined type alias TransactionCount\n\nval allData: RDD[(User,TransactionCount)] =\n sc.makeRDD((\"Bob\", 12) :: (\"Joe\", 1) :: (\"Anna\", 100) :: (\"Bob\", 20) :: (\"Joe\", 2) :: Nil)\n// allData: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ParallelCollectionRDD[14] at makeRDD at :46\n\nval totalPerUser = allData.csumByKey\n// totalPerUser: org.apache.spark.rdd.RDD[(User, TransactionCount)] = ShuffledRDD[15] at reduceByKey at implicits.scala:42\n\ntotalPerUser.collectAsMap\n// res16: scala.collection.Map[User,TransactionCount] = Map(Bob -> 32, Joe -> 3, Anna -> 100)\n\nThe same example would work for more complex keys.\nimport scala.collection.immutable.SortedMap\n// import scala.collection.immutable.SortedMap\n\nval allDataComplexKeu =\n sc.makeRDD( (\"Bob\", SortedMap(\"task1\" -> 10)) ::\n (\"Joe\", SortedMap(\"task1\" -> 1, \"task2\" -> 3)) :: (\"Bob\", SortedMap(\"task1\" -> 10, \"task2\" -> 1)) :: (\"Joe\", SortedMap(\"task3\" -> 4)) :: Nil )\n// allDataComplexKeu: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ParallelCollectionRDD[16] at makeRDD at :45\n\nval overalTasksPerUser = allDataComplexKeu.csumByKey\n// overalTasksPerUser: org.apache.spark.rdd.RDD[(String, scala.collection.immutable.SortedMap[String,Int])] = ShuffledRDD[17] at reduceByKey at implicits.scala:42\n\noveralTasksPerUser.collectAsMap\n// res17: scala.collection.Map[String,scala.collection.immutable.SortedMap[String,Int]] = Map(Bob -> Map(task1 -> 20, task2 -> 1), Joe -> Map(task1 -> 1, task2 -> 3, task3 -> 4))\n\nJoins\n// Type aliases for meaningful types\ntype TimeSeries = Map[Int,Int]\n// defined type alias TimeSeries\n\ntype UserName = String\n// defined type alias UserName\n\nExample: Using the implicit full-our-join operator\nimport frameless.cats.outer._\n// import frameless.cats.outer._\n\nval day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 2, 1 -> 4)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Sam\", Map(0 -> 1)) :: Nil )\n// day1: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[18] at makeRDD at :49\n\nval day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( (\"John\", Map(0 -> 10, 1 -> 11)) :: (\"Chris\", Map(0 -> 1, 1 -> 2)) :: (\"Joe\", Map(0 -> 1, 1 -> 2)) :: Nil )\n// day2: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[19] at makeRDD at :49\n\nval daysCombined = day1 |+| day2\n// daysCombined: org.apache.spark.rdd.RDD[(UserName, TimeSeries)] = MapPartitionsRDD[23] at mapValues at implicits.scala:67\n\ndaysCombined.collect()\n// res19: Array[(UserName, TimeSeries)] = Array((Joe,Map(0 -> 1, 1 -> 2)), (Sam,Map(0 -> 1)), (Chris,Map(0 -> 2, 1 -> 4)), (John,Map(0 -> 12, 1 -> 15)))\n\nNote how the user's timeseries from different days have been aggregated together.\nThe |+| (Semigroup) operator for key-value pair RDD will execute a full-outer-join\non the key and combine values using the default Semigroup for the value type.\nIn cats:\nMap(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)\n// res20: scala.collection.immutable.Map[Int,Int] = Map(1 -> 6, 2 -> 2)\n\n"},"TypedML.html":{"url":"TypedML.html","title":"Using Spark ML with TypedDataset","keywords":"","body":"Typed Spark ML\nThe frameless-ml module provides a strongly typed Spark ML API leveraging TypedDatasets. It introduces TypedTransformers\nand TypedEstimators, the type-safe equivalents of Spark ML's Transformer and Estimator. \nA TypedEstimator fits models to data, i.e trains a ML model based on an input TypedDataset. \nA TypedTransformer transforms one TypedDataset into another, usually by appending column(s) to it.\nBy calling the fit method of a TypedEstimator, the TypedEstimator will train a ML model using the TypedDataset \npassed as input (representing the training data) and will return a TypedTransformer that represents the trained model. \nThis TypedTransformercan then be used to make predictions on an input TypedDataset (representing the test data) \nusing the transform method that will return a new TypedDataset with appended prediction column(s).\nBoth TypedEstimator and TypedTransformer check at compile-time the correctness of their inputs field names and types,\ncontrary to Spark ML API which only deals with DataFrames (the data structure with the lowest level of type-safety in Spark).\nframeless-ml adds type-safety to Spark ML API but stays very close to it in terms of abstractions and API calls, so \nplease check Spark ML documentation for more details \non Transformers and Estimators.\nExample 1: predict a continuous value using a TypedRandomForestRegressor\nIn this example, we want to predict the sale price of a house depending on its square footage and the fact that the house\nhas a garden or not. We will use a TypedRandomForestRegressor.\nTraining\nAs with the Spark ML API, we use a TypedVectorAssembler (the type-safe equivalent of VectorAssembler)\nto compute feature vectors:\nimport frameless._\nimport frameless.syntax._\nimport frameless.ml._\nimport frameless.ml.feature._\nimport frameless.ml.regression._\nimport org.apache.spark.ml.linalg.Vector\n\ncase class HouseData(squareFeet: Double, hasGarden: Boolean, price: Double)\n// defined class HouseData\n\nval trainingData = TypedDataset.create(Seq(\n HouseData(20, false, 100000),\n HouseData(50, false, 200000),\n HouseData(50, true, 250000),\n HouseData(100, true, 500000)\n))\n// trainingData: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]\n\ncase class Features(squareFeet: Double, hasGarden: Boolean)\n// defined class Features\n\nval assembler = TypedVectorAssembler[Features]\n// assembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@a559710\n\ncase class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector)\n// defined class HouseDataWithFeatures\n\nval trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures]\n// trainingDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]\n\nIn the above code snippet, .as[HouseDataWithFeatures] is a TypedDataset's type-safe cast\n(see TypedDataset: Feature Overview):\ncase class WrongHouseFeatures(\n squareFeet: Double,\n hasGarden: Int, // hasGarden has wrong type\n price: Double,\n features: Vector\n)\n\nassembler.transform(trainingData).as[WrongHouseFeatures]\n// :39: error: could not find implicit value for parameter as: frameless.ops.As[(Double, Boolean, Double, org.apache.spark.ml.linalg.Vector),WrongHouseFeatures]\n// assembler.transform(trainingData).as[WrongHouseFeatures]\n// ^\n\nMoreover, TypedVectorAssembler[Features] will compile only if Features contains exclusively fields of type Numeric or Boolean:\ncase class WrongFeatures(squareFeet: Double, hasGarden: Boolean, city: String)\n\nTypedVectorAssembler[WrongFeatures]\n// :37: error: Cannot prove that WrongFeatures is a valid input type. Input type must only contain fields of numeric or boolean types.\n// TypedVectorAssembler[WrongFeatures]\n// ^\n\nThe subsequent call assembler.transform(trainingData) compiles only if trainingData contains all fields (names and types)\nof Features:\ncase class WrongHouseData(squareFeet: Double, price: Double) // hasGarden is missing\n// defined class WrongHouseData\n\nval wrongTrainingData = TypedDataset.create(Seq(WrongHouseData(20, 100000)))\n// wrongTrainingData: frameless.TypedDataset[WrongHouseData] = [squareFeet: double, price: double]\n\nassembler.transform(wrongTrainingData)\n// :37: error: Cannot prove that WrongHouseData can be projected to Features. Perhaps not all member names and types of Features are the same in WrongHouseData?\n// assembler.transform(wrongTrainingData)\n// ^\n\nThen, we train the model. To train a Random Forest, one needs to feed it with features (what we predict from) and\nwith a label (what we predict). In our example, price is the label, features are the features:\ncase class RFInputs(price: Double, features: Vector)\n// defined class RFInputs\n\nval rf = TypedRandomForestRegressor[RFInputs]\n// rf: frameless.ml.regression.TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@37d61f51\n\nval model = rf.fit(trainingDataWithFeatures).run()\n// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.regression.TypedRandomForestRegressor.Outputs,org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@5d5c3\n\nTypedRandomForestRegressor[RFInputs] compiles only if RFInputs\ncontains only one field of type Double (the label) and one field of type Vector (the features):\ncase class WrongRFInputs(labelOfWrongType: String, features: Vector)\n\nTypedRandomForestRegressor[WrongRFInputs]\n// :37: error: Cannot prove that WrongRFInputs is a valid input type. Input type must only contain a field of type Double (the label) and a field of type org.apache.spark.ml.linalg.Vector (the features).\n// TypedRandomForestRegressor[WrongRFInputs]\n// ^\n\nThe subsequent rf.fit(trainingDataWithFeatures) call compiles only if trainingDataWithFeatures contains the same fields\n(names and types) as RFInputs.\nval wrongTrainingDataWithFeatures = TypedDataset.create(Seq(HouseData(20, false, 100000))) // features are missing\n// wrongTrainingDataWithFeatures: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]\n\nrf.fit(wrongTrainingDataWithFeatures) \n// :37: error: Cannot prove that HouseData can be projected to RFInputs. Perhaps not all member names and types of RFInputs are the same in HouseData?\n// rf.fit(wrongTrainingDataWithFeatures)\n// ^\n\nPrediction\nWe now want to predict price for testData using the previously trained model. Like the Spark ML API,\ntestData has a default value for price (0 in our case) that will be ignored at prediction time. We reuse\nour assembler to compute the feature vector of testData.\nval testData = TypedDataset.create(Seq(HouseData(70, true, 0)))\n// testData: frameless.TypedDataset[HouseData] = [squareFeet: double, hasGarden: boolean ... 1 more field]\n\nval testDataWithFeatures = assembler.transform(testData).as[HouseDataWithFeatures]\n// testDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, hasGarden: boolean ... 2 more fields]\n\ncase class HousePricePrediction(\n squareFeet: Double,\n hasGarden: Boolean,\n price: Double,\n features: Vector,\n predictedPrice: Double\n)\n// defined class HousePricePrediction\n\nval predictions = model.transform(testDataWithFeatures).as[HousePricePrediction]\n// predictions: frameless.TypedDataset[HousePricePrediction] = [squareFeet: double, hasGarden: boolean ... 3 more fields]\n\npredictions.select(predictions.col('predictedPrice)).collect.run()\n// res6: Seq[Double] = WrappedArray(296250.0)\n\nmodel.transform(testDataWithFeatures) will only compile if testDataWithFeatures contains a field price of type Double\nand a field features of type Vector:\nmodel.transform(testData)\n// :37: error: Cannot prove that HouseData can be projected to RFInputs. Perhaps not all member names and types of RFInputs are the same in HouseData?\n// model.transform(testData)\n// ^\n\nExample 2: predict a categorical value using a TypedRandomForestClassifier\nIn this example, we want to predict in which city a house is located depending on its price and its square footage. We use a\nTypedRandomForestClassifier.\nTraining\nAs with the Spark ML API, we use a TypedVectorAssembler to compute feature vectors and a TypedStringIndexer\nto index city values in order to be able to pass them to a TypedRandomForestClassifier\n(which only accepts Double values as label):\nimport frameless.ml.classification._\n\ncase class HouseData(squareFeet: Double, city: String, price: Double)\n// defined class HouseData\n\nval trainingData = TypedDataset.create(Seq(\n HouseData(100, \"lyon\", 100000),\n HouseData(200, \"lyon\", 200000),\n HouseData(100, \"san francisco\", 500000),\n HouseData(150, \"san francisco\", 900000)\n))\n// trainingData: frameless.TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]\n\ncase class Features(price: Double, squareFeet: Double)\n// defined class Features\n\nval vectorAssembler = TypedVectorAssembler[Features]\n// vectorAssembler: frameless.ml.feature.TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@eb06753\n\ncase class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector)\n// defined class HouseDataWithFeatures\n\nval dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures]\n// dataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]\n\ncase class StringIndexerInput(city: String)\n// defined class StringIndexerInput\n\nval indexer = TypedStringIndexer[StringIndexerInput]\n// indexer: frameless.ml.feature.TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@4c2621e0\n\nindexer.estimator.setHandleInvalid(\"keep\")\n// res8: indexer.estimator.type = strIdx_267bc5cb88b4\n\nval indexerModel = indexer.fit(dataWithFeatures).run()\n// indexerModel: frameless.ml.AppendTransformer[StringIndexerInput,frameless.ml.feature.TypedStringIndexer.Outputs,org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@6145e82d\n\ncase class HouseDataWithFeaturesAndIndex(\n squareFeet: Double,\n city: String,\n price: Double,\n features: Vector,\n cityIndexed: Double\n)\n// defined class HouseDataWithFeaturesAndIndex\n\nval indexedData = indexerModel.transform(dataWithFeatures).as[HouseDataWithFeaturesAndIndex]\n// indexedData: frameless.TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]\n\nThen, we train the model:\ncase class RFInputs(cityIndexed: Double, features: Vector)\n// defined class RFInputs\n\nval rf = TypedRandomForestClassifier[RFInputs]\n// rf: frameless.ml.classification.TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@33ab9b32\n\nval model = rf.fit(indexedData).run()\n// model: frameless.ml.AppendTransformer[RFInputs,frameless.ml.classification.TypedRandomForestClassifier.Outputs,org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@5bd75b8e\n\nPrediction\nWe now want to predict city for testData using the previously trained model. Like the Spark ML API,\ntestData has a default value for city (empty string in our case) that will be ignored at prediction time. We reuse\nour vectorAssembler to compute the feature vector of testData and our indexerModel to index city.\nval testData = TypedDataset.create(Seq(HouseData(120, \"\", 800000)))\n// testData: frameless.TypedDataset[HouseData] = [squareFeet: double, city: string ... 1 more field]\n\nval testDataWithFeatures = vectorAssembler.transform(testData).as[HouseDataWithFeatures]\n// testDataWithFeatures: frameless.TypedDataset[HouseDataWithFeatures] = [squareFeet: double, city: string ... 2 more fields]\n\nval indexedTestData = indexerModel.transform(testDataWithFeatures).as[HouseDataWithFeaturesAndIndex]\n// indexedTestData: frameless.TypedDataset[HouseDataWithFeaturesAndIndex] = [squareFeet: double, city: string ... 3 more fields]\n\ncase class HouseCityPredictionInputs(features: Vector, cityIndexed: Double)\n// defined class HouseCityPredictionInputs\n\nval testInput = indexedTestData.project[HouseCityPredictionInputs]\n// testInput: frameless.TypedDataset[HouseCityPredictionInputs] = [features: vector, cityIndexed: double]\n\ncase class HouseCityPredictionIndexed(\n features: Vector,\n cityIndexed: Double,\n rawPrediction: Vector,\n probability: Vector,\n predictedCityIndexed: Double\n)\n// defined class HouseCityPredictionIndexed\n\nval indexedPredictions = model.transform(testInput).as[HouseCityPredictionIndexed]\n// indexedPredictions: frameless.TypedDataset[HouseCityPredictionIndexed] = [features: vector, cityIndexed: double ... 3 more fields]\n\nThen, we use a TypedIndexToString to get back a String value from predictedCityIndexed. TypedIndexToString takes\nas input the label array computed by our previous indexerModel:\ncase class IndexToStringInput(predictedCityIndexed: Double)\n// defined class IndexToStringInput\n\nval indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)\n// :40: warning: method labels in class StringIndexerModel is deprecated (since 3.0.0): `labels` is deprecated and will be removed in 3.1.0. Use `labelsArray` instead.\n// val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)\n// ^\n// indexToString: frameless.ml.feature.TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@355dd92d\n\ncase class HouseCityPrediction(\n features: Vector,\n cityIndexed: Double,\n rawPrediction: Vector,\n probability: Vector,\n predictedCityIndexed: Double,\n predictedCity: String\n)\n// defined class HouseCityPrediction\n\nval predictions = indexToString.transform(indexedPredictions).as[HouseCityPrediction]\n// predictions: frameless.TypedDataset[HouseCityPrediction] = [features: vector, cityIndexed: double ... 4 more fields]\n\npredictions.select(predictions.col('predictedCity)).collect.run()\n// res9: Seq[String] = WrappedArray(san francisco)\n\nList of currently implemented TypedEstimators\n\nTypedRandomForestClassifier\nTypedRandomForestRegressor\n... your contribution here ... :)\n\nList of currently implemented TypedTransformers\n\nTypedIndexToString\nTypedStringIndexer\nTypedVectorAssembler\n... your contribution here ... :)\n\nUsing Vector and Matrix with TypedDataset\nframeless-ml provides TypedEncoder instances for org.apache.spark.ml.linalg.Vector \nand org.apache.spark.ml.linalg.Matrix:\nimport frameless._\nimport frameless.ml._\nimport org.apache.spark.ml.linalg._\n\nval vector = Vectors.dense(1, 2, 3)\n// vector: org.apache.spark.ml.linalg.Vector = [1.0,2.0,3.0]\n\nval vectorDs = TypedDataset.create(Seq(\"label\" -> vector))\n// vectorDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Vector)] = [_1: string, _2: vector]\n\nval matrix = Matrices.dense(2, 1, Array(1, 2))\n// matrix: org.apache.spark.ml.linalg.Matrix =\n// 1.0\n// 2.0\n\nval matrixDs = TypedDataset.create(Seq(\"label\" -> matrix))\n// matrixDs: frameless.TypedDataset[(String, org.apache.spark.ml.linalg.Matrix)] = [_1: string, _2: matrix]\n\nUnder the hood, Vector and Matrix are encoded using org.apache.spark.ml.linalg.VectorUDT \nand org.apache.spark.ml.linalg.MatrixUDT. This is possible thanks to the implicit derivation \nfrom org.apache.spark.sql.types.UserDefinedType[A] to TypedEncoder[A] defined in TypedEncoder companion object.\n"},"TypedDataFrame.html":{"url":"TypedDataFrame.html","title":"Proof of Concept: TypedDataFrame","keywords":"","body":"Proof of Concept: TypedDataFrame\nTypedDataFrame is the API developed in the early stages of Frameless to manipulate Spark DataFrames in a type-safe manner. With the introduction of Dataset in Spark 1.6, DataFrame seems deprecated and won't be the focus of future development of Frameless. However, the design is interesting enough to document.\nTo safely manipulate DataFrames we use a technique called a shadow type, which consists in storing additional information about a value in a \"dummy\" type. Mirroring value-level computation at the type-level lets us leverage the type system to catch common mistakes at compile time.\nDiving in\nIn TypedDataFrame, we use a single Schema to model the number, the types and the names of columns. Here is a what the definition of TypedDataFrame looks like, with simplified type signatures:\nimport org.apache.spark.sql.DataFrame\nimport shapeless.HList\n\nclass TDataFrame[Schema Boolean): TDataFrame[Schema] = ???\n\n def select[C \nAs you can see, instead of the def filter(conditionExpr: String): DataFrame defined in Spark, the TypedDataFrame version expects a function from Schema to Boolean, and models the fact that resulting DataFrame will still hold elements of type Schema.\nType-level column referencing\nFor Spark's DataFrames, column referencing is done directly by Strings or using the Column type which provides no additional type safety. TypedDataFrame improves on that by catching invalid column references compile type. When everything goes well, Frameless select is very similar to vanilla select, except that it keeps track of the selected column types:\nimport frameless.TypedDataFrame\n\ncase class Foo(s: String, d: Double, i: Int)\n\ndef selectIntString(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n tf.select('i, 's)\n\nHowever, in case of typo, it gets caught right away:\ndef selectIntStringTypo(tf: TypedDataFrame[Foo]): TypedDataFrame[(Int, String)] =\n tf.select('j, 's)\n\nType-level joins\nJoins can available with two different syntaxes. The first lets you reference different columns on each TypedDataFrame, and ensures that they all exist and have compatible types:\ncase class Bar(i: Int, j: String, b: Boolean)\n\ndef join1(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n : TypedDataFrame[(String, Double, Int, Int, String, Boolean)] =\n tf1.innerJoin(tf2).on('s).and('j)\n\nThe second syntax brings some convenience when the joining columns have identical names in both tables:\ndef join2(tf1: TypedDataFrame[Foo], tf2: TypedDataFrame[Bar])\n : TypedDataFrame[(String, Double, Int, String, Boolean)] =\n tf1.innerJoin(tf2).using('i)\n\nFurther example are available in the TypedDataFrame join tests.\nComplete example\nWe now consider a complete example to see how the Frameless types can improve not only correctness but also the readability of Spark jobs. Consider the following domain of phonebooks, city maps and neighborhoods:\ntype Neighborhood = String\ntype Address = String\n\ncase class PhoneBookEntry(\n address: Address,\n residents: String,\n phoneNumber: Double\n)\n\ncase class CityMapEntry(\n address: Address,\n neighborhood: Neighborhood\n)\n\nOur goal will be to compute the neighborhood with unique names, approximating \"unique\" with names containing less common\nletters in the alphabet: 'x', 'q', and 'z'. We are going to need a natural language processing library at some point, so\nlet's use the following for the example:\nobject NLPLib {\n def uniqueName(name: String): Boolean = name.exists(Set('x', 'q', 'z'))\n}\n\nSuppose we manage to obtain public data for a TypedDataFrame[PhoneBookEntry] and TypedDataFrame[CityMapEntry]. Here is what our Spark job could look like with Frameless:\nimport org.apache.spark.sql.SQLContext\n\n// These case classes are used to hold intermediate results\ncase class Family(residents: String, neighborhood: Neighborhood)\ncase class Person(name: String, neighborhood: Neighborhood)\ncase class NeighborhoodCount(neighborhood: Neighborhood, count: Long)\n\ndef bestNeighborhood\n (phoneBookTF: TypedDataFrame[PhoneBookEntry], cityMapTF: TypedDataFrame[CityMapEntry])\n (implicit c: SQLContext): String = {\n (((((((((\n phoneBookTF\n .innerJoin(cityMapTF).using('address) :TypedDataFrame[(Address, String, Double, String)])\n .select('_2, '_4) :TypedDataFrame[(String, String)])\n .as[Family]() :TypedDataFrame[Family])\n .flatMap { f =>\n f.residents.split(' ').map(r => Person(r, f.neighborhood))\n } :TypedDataFrame[Person])\n .filter { p =>\n NLPLib.uniqueName(p.name)\n } :TypedDataFrame[Person])\n .groupBy('neighborhood).count() :TypedDataFrame[(String, Long)])\n .as[NeighborhoodCount]() :TypedDataFrame[NeighborhoodCount])\n .sortDesc('count) :TypedDataFrame[NeighborhoodCount])\n .select('neighborhood) :TypedDataFrame[Tuple1[String]])\n .head._1\n}\n\nIf you compare this version to vanilla Spark where every line is a DataFrame, you see how much types can improve readability. An executable version of this example is available in the BestNeighborhood test.\nLimitations\nThe main limitation of this approach comes from Scala 2.10, which limits the arity of class classes to 22. Because of the way DataFrame models joins, joining two table with more that 11 fields results in a DataFrame which not representable with Schema of type Product.\nIn the Dataset API introduced in Spark 1.6, the way join are handled was rethought to return a pair of both schemas instead of a flat table, which moderates the trouble caused by case class limitations. Alternatively, since Scala 2.11, it is possible to define Tuple23 and onward. Sadly, due to the way Spark is commonly packaged in various systems, the amount Spark users having to Scala 2.11 and not to Spark 1.6 is essentially zero. For this reasons, further development in Frameless will target Spark 1.6+, deprecating the early work onTypedDataFrame.\n"}}} \ No newline at end of file diff --git a/version.sbt b/version.sbt deleted file mode 100644 index 468375832..000000000 --- a/version.sbt +++ /dev/null @@ -1 +0,0 @@ -version in ThisBuild := "0.10.0-SNAPSHOT" From a663b0880ee1a976f447f1ac06509c669c505016 Mon Sep 17 00:00:00 2001 From: pomadchin Date: Wed, 26 Jan 2022 03:26:02 +0000 Subject: [PATCH 007/220] deploy: 9bd71355c468c1a86abfda9d624c8bf0d2cb2866 --- Cats.html | 4 ++-- FeatureOverview.html | 2 +- Injection.html | 8 ++++---- Job.html | 4 ++-- TypedEncoder.html | 2 +- TypedML.html | 20 ++++++++++---------- 6 files changed, 20 insertions(+), 20 deletions(-) diff --git a/Cats.html b/Cats.html index 24e9133d5..7b305bcd4 100644 --- a/Cats.html +++ b/Cats.html @@ -119,7 +119,7 @@

                              Effect Suspension i count <- typedDs.count[Action]() } yield (sample, count) // result: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$13173/1148508813@3ef9fdf +// cats.data.Kleisli$$$Lambda$13154/2115923594@56b9955d // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -144,7 +144,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$13173/1148508813@68e35367 +// cats.data.Kleisli$$$Lambda$13154/2115923594@69bfc236 // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index d2b6de0a0..e9cb052a5 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -682,7 +682,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15393/1583643801@75d108db +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15381/1012762607@626e0165 val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index 386a4dde5..c2dd202f0 100644 --- a/Injection.html +++ b/Injection.html @@ -96,7 +96,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Wed Jan 26 01:09:01 UTC 2022)) +// people: Seq[Person] = List(Person(42, Wed Jan 26 03:25:18 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -109,11 +109,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@4500fae4
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@6ed13549

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@6cef1fa2
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@71373e44

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -146,7 +146,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@3951bf91 +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@6d7aa84

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index 57f0ce2a8..94b41b6e3 100644 --- a/Job.html +++ b/Job.html @@ -109,7 +109,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@44e99d4f +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@4cef7c44 countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -120,7 +120,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@1ab7a43a +// finalJob: Job[Int] = frameless.Job$$anon$2@6557ae9c

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index 4a088fee8..3d3130451 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -138,7 +138,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@3d8cdc0a +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@9ce79b

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index 43c901789..3646e73d5 100644 --- a/TypedML.html +++ b/TypedML.html @@ -131,7 +131,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@604ca2fd +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@3696e8ed case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -167,10 +167,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@e882e0b +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@66ed279 val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@38d8d51b +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@7dec926

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -236,7 +236,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@40d7ae21 +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@6d62611d case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -244,11 +244,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@91f3043 +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@13d356cb indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_939a8eadf96b +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_1b748dfe2467 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@329efd3e +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@718022d7 case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -262,10 +262,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@26ebb6de +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@3b877cc1 val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@5bb0a284 +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@45139825

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -296,7 +296,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@2b5d1c99
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@4cffeb42
 
 case class HouseCityPrediction(
   features: Vector,

From 261fc9598f4d839dd198d4448b43f736929b0769 Mon Sep 17 00:00:00 2001
From: pomadchin 
Date: Wed, 26 Jan 2022 13:42:24 +0000
Subject: [PATCH 008/220] deploy: 3becb709544ca779c4856152c0ac3f243ffe40f0

---
 Cats.html            |  4 ++--
 FeatureOverview.html |  2 +-
 Injection.html       |  8 ++++----
 Job.html             |  4 ++--
 TypedEncoder.html    |  2 +-
 TypedML.html         | 20 ++++++++++----------
 6 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/Cats.html b/Cats.html
index 7b305bcd4..f3cd6719e 100644
--- a/Cats.html
+++ b/Cats.html
@@ -119,7 +119,7 @@ 
                              Effect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$13154/2115923594@56b9955d
+//   cats.data.Kleisli$$$Lambda$13154/1038093454@1c018254
 // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -144,7 +144,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$13154/2115923594@69bfc236 +// cats.data.Kleisli$$$Lambda$13154/1038093454@74710be1 // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index e9cb052a5..7842fae5c 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -682,7 +682,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15381/1012762607@626e0165 +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15394/1996586087@2e99236a val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index c2dd202f0..4e5ea3d45 100644 --- a/Injection.html +++ b/Injection.html @@ -96,7 +96,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Wed Jan 26 03:25:18 UTC 2022)) +// people: Seq[Person] = List(Person(42, Wed Jan 26 13:41:40 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -109,11 +109,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@6ed13549
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@3b857fa2

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@71373e44
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@40d7a45b

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -146,7 +146,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@6d7aa84 +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@567eb64

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index 94b41b6e3..353a0063d 100644 --- a/Job.html +++ b/Job.html @@ -109,7 +109,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@4cef7c44 +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@25d6169a countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -120,7 +120,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@6557ae9c +// finalJob: Job[Int] = frameless.Job$$anon$2@7ce00f0e

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index 3d3130451..53e016a9b 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -138,7 +138,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@9ce79b +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@39466745

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index 3646e73d5..3b816e1b0 100644 --- a/TypedML.html +++ b/TypedML.html @@ -131,7 +131,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@3696e8ed +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@74a4b279 case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -167,10 +167,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@66ed279 +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@775582cf val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@7dec926 +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@3797b4f6

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -236,7 +236,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@6d62611d +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@78585bdc case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -244,11 +244,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@13d356cb +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@3124d9db indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_1b748dfe2467 +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_13f325a42b5f val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@718022d7 +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@68894051 case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -262,10 +262,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@3b877cc1 +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@777b31d1 val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@45139825 +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@4d470259

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -296,7 +296,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@4cffeb42
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@5a3af02b
 
 case class HouseCityPrediction(
   features: Vector,

From 80c9c2aabe7d32dffd316cab9cffbe905acaa935 Mon Sep 17 00:00:00 2001
From: pomadchin 
Date: Wed, 26 Jan 2022 22:33:43 +0000
Subject: [PATCH 009/220] deploy: 46f40b0727c27dc3caa5fa4c7f495128b25ce5dd

---
 Cats.html            |  4 ++--
 FeatureOverview.html |  2 +-
 Injection.html       |  8 ++++----
 Job.html             |  4 ++--
 TypedEncoder.html    |  2 +-
 TypedML.html         | 20 ++++++++++----------
 6 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/Cats.html b/Cats.html
index f3cd6719e..48e77cb38 100644
--- a/Cats.html
+++ b/Cats.html
@@ -119,7 +119,7 @@ 
                              Effect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$13154/1038093454@1c018254
+//   cats.data.Kleisli$$$Lambda$13142/1810167349@2914e785
 // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -144,7 +144,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$13154/1038093454@74710be1 +// cats.data.Kleisli$$$Lambda$13142/1810167349@69a2d1bc // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index 7842fae5c..74d482e25 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -682,7 +682,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15394/1996586087@2e99236a +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15376/1987344558@362f186a val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index 4e5ea3d45..3bc06dfc5 100644 --- a/Injection.html +++ b/Injection.html @@ -96,7 +96,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Wed Jan 26 13:41:40 UTC 2022)) +// people: Seq[Person] = List(Person(42, Wed Jan 26 22:33:04 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -109,11 +109,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@3b857fa2
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@35bfbd66

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@40d7a45b
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@1b6e6d78

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -146,7 +146,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@567eb64 +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@4070ff14

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index 353a0063d..b79329ce2 100644 --- a/Job.html +++ b/Job.html @@ -109,7 +109,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@25d6169a +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@510fa980 countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -120,7 +120,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@7ce00f0e +// finalJob: Job[Int] = frameless.Job$$anon$2@55f51b32

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index 53e016a9b..c1d49df76 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -138,7 +138,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@39466745 +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@4efef16b

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index 3b816e1b0..b6f004ea8 100644 --- a/TypedML.html +++ b/TypedML.html @@ -131,7 +131,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@74a4b279 +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@6296f8cf case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -167,10 +167,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@775582cf +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@30d41acc val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@3797b4f6 +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@6f5f8514

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -236,7 +236,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@78585bdc +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@43f0bde0 case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -244,11 +244,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@3124d9db +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@60b66ad1 indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_13f325a42b5f +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_73d17877b117 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@68894051 +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@23b34d4e case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -262,10 +262,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@777b31d1 +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@374674ce val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@4d470259 +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@719fc07b

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -296,7 +296,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@5a3af02b
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@22accc7b
 
 case class HouseCityPrediction(
   features: Vector,

From 7aff9c18553f0c6ffb469af9676ee817500a966a Mon Sep 17 00:00:00 2001
From: pomadchin 
Date: Wed, 26 Jan 2022 22:41:26 +0000
Subject: [PATCH 010/220] deploy: 29961d549e332dddf5cd711ef699dde7460cc48a

---
 Cats.html                       |  4 ++--
 FeatureOverview.html            |  8 ++++----
 Injection.html                  |  8 ++++----
 Job.html                        |  4 ++--
 TypedDatasetVsSparkDataset.html | 14 +++++++-------
 TypedEncoder.html               |  2 +-
 TypedML.html                    | 20 ++++++++++----------
 WorkingWithCsvParquetJson.html  | 10 +++++-----
 8 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/Cats.html b/Cats.html
index 48e77cb38..39663bf74 100644
--- a/Cats.html
+++ b/Cats.html
@@ -119,7 +119,7 @@ 
                              Effect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$13142/1810167349@2914e785
+//   cats.data.Kleisli$$$Lambda$13159/1088316408@1cffd3a9
 // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -144,7 +144,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$13142/1810167349@69a2d1bc +// cats.data.Kleisli$$$Lambda$13159/1088316408@2870fab8 // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index 74d482e25..a0b18bf0e 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -184,10 +184,10 @@

                              Typesafe column referencing // at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:263) // at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:94) // at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:91) -// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:172) -// at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:195) +// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:182) +// at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:205) // at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:330) -// at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:192) +// at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:202) // at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:88) // at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111) // at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:196) @@ -682,7 +682,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15376/1987344558@362f186a +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15388/1266882367@62c48513 val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index 3bc06dfc5..a92cb3c17 100644 --- a/Injection.html +++ b/Injection.html @@ -96,7 +96,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Wed Jan 26 22:33:04 UTC 2022)) +// people: Seq[Person] = List(Person(42, Wed Jan 26 22:40:48 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -109,11 +109,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@35bfbd66
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@483eafa9

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@1b6e6d78
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@264f876b

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -146,7 +146,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@4070ff14 +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@5432ce75

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index b79329ce2..66c5cd9fc 100644 --- a/Job.html +++ b/Job.html @@ -109,7 +109,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@510fa980 +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@629a9eb2 countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -120,7 +120,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@55f51b32 +// finalJob: Job[Int] = frameless.Job$$anon$2@42d23bb4

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedDatasetVsSparkDataset.html b/TypedDatasetVsSparkDataset.html index f9e72916d..1a0fc1579 100644 --- a/TypedDatasetVsSparkDataset.html +++ b/TypedDatasetVsSparkDataset.html @@ -183,10 +183,10 @@

                              Comparing T // at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:263) // at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:94) // at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:91) -// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:172) -// at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:195) +// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:182) +// at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:205) // at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:330) -// at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:192) +// at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:202) // at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:88) // at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111) // at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:196) @@ -327,7 +327,7 @@

                              Aggregate vs Projected c // // at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.failAnalysis(CheckAnalysis.scala:51) // at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.failAnalysis$(CheckAnalysis.scala:50) -// at org.apache.spark.sql.catalyst.analysis.Analyzer.failAnalysis(Analyzer.scala:172) +// at org.apache.spark.sql.catalyst.analysis.Analyzer.failAnalysis(Analyzer.scala:182) // at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkValidAggregateExpression$1(CheckAnalysis.scala:296) // at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$13(CheckAnalysis.scala:311) // at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.$anonfun$checkAnalysis$13$adapted(CheckAnalysis.scala:311) @@ -357,10 +357,10 @@

                              Aggregate vs Projected c // at org.apache.spark.sql.catalyst.trees.TreeNode.foreachUp(TreeNode.scala:263) // at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis(CheckAnalysis.scala:94) // at org.apache.spark.sql.catalyst.analysis.CheckAnalysis.checkAnalysis$(CheckAnalysis.scala:91) -// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:172) -// at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:195) +// at org.apache.spark.sql.catalyst.analysis.Analyzer.checkAnalysis(Analyzer.scala:182) +// at org.apache.spark.sql.catalyst.analysis.Analyzer.$anonfun$executeAndCheck$1(Analyzer.scala:205) // at org.apache.spark.sql.catalyst.plans.logical.AnalysisHelper$.markInAnalyzer(AnalysisHelper.scala:330) -// at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:192) +// at org.apache.spark.sql.catalyst.analysis.Analyzer.executeAndCheck(Analyzer.scala:202) // at org.apache.spark.sql.execution.QueryExecution.$anonfun$analyzed$1(QueryExecution.scala:88) // at org.apache.spark.sql.catalyst.QueryPlanningTracker.measurePhase(QueryPlanningTracker.scala:111) // at org.apache.spark.sql.execution.QueryExecution.$anonfun$executePhase$1(QueryExecution.scala:196) diff --git a/TypedEncoder.html b/TypedEncoder.html index c1d49df76..fea8a117b 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -138,7 +138,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@4efef16b +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@696093bd

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index b6f004ea8..136d98878 100644 --- a/TypedML.html +++ b/TypedML.html @@ -131,7 +131,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@6296f8cf +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@3b617eb8 case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -167,10 +167,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@30d41acc +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@5b272084 val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@6f5f8514 +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@78fefb3a

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -236,7 +236,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@43f0bde0 +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@2d33bf1 case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -244,11 +244,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@60b66ad1 +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@2003248 indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_73d17877b117 +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_dbe40cbb3ba3 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@23b34d4e +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@1988a6e5 case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -262,10 +262,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@374674ce +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@481c79bc val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@719fc07b +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@538bdffd

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -296,7 +296,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@22accc7b
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@501a35b6
 
 case class HouseCityPrediction(
   features: Vector,
diff --git a/WorkingWithCsvParquetJson.html b/WorkingWithCsvParquetJson.html
index 020e33dab..9a6588b4b 100644
--- a/WorkingWithCsvParquetJson.html
+++ b/WorkingWithCsvParquetJson.html
@@ -167,12 +167,12 @@ 
                              Working with CSVEffect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$13159/1088316408@1cffd3a9
+//   cats.data.Kleisli$$$Lambda$13163/1874009418@2c520fe6
 // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -144,7 +144,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$13159/1088316408@2870fab8 +// cats.data.Kleisli$$$Lambda$13163/1874009418@3bc26697 // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index a0b18bf0e..80bbd20a0 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -682,7 +682,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15388/1266882367@62c48513 +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15401/318557069@309595c0 val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index a92cb3c17..43559ef5f 100644 --- a/Injection.html +++ b/Injection.html @@ -96,7 +96,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Wed Jan 26 22:40:48 UTC 2022)) +// people: Seq[Person] = List(Person(42, Tue Feb 01 12:22:12 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -109,11 +109,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@483eafa9
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@539cbf3b

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@264f876b
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@4b55c5d6

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -146,7 +146,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@5432ce75 +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@77d95687

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index 66c5cd9fc..b80321f9c 100644 --- a/Job.html +++ b/Job.html @@ -109,7 +109,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@629a9eb2 +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@4d72965d countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -120,7 +120,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@42d23bb4 +// finalJob: Job[Int] = frameless.Job$$anon$2@33e63178

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index fea8a117b..a44086e25 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -138,7 +138,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@696093bd +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@4b75a1d2

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index 136d98878..3c3711c29 100644 --- a/TypedML.html +++ b/TypedML.html @@ -131,7 +131,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@3b617eb8 +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@7bae123 case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -167,10 +167,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@5b272084 +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@7f84970f val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@78fefb3a +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@64c1e428

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -236,7 +236,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@2d33bf1 +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@1fe1a142 case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -244,11 +244,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@2003248 +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@de6f28 indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_dbe40cbb3ba3 +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_2f84b2ab5e63 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@1988a6e5 +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@5389fd67 case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -262,10 +262,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@481c79bc +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@42c49d0e val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@538bdffd +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@50bddfa5

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -296,7 +296,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@501a35b6
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@23695db5
 
 case class HouseCityPrediction(
   features: Vector,

From 223a93aa07447b6f545b458cbe1b592930fd991c Mon Sep 17 00:00:00 2001
From: pomadchin 
Date: Tue, 1 Feb 2022 13:33:42 +0000
Subject: [PATCH 012/220] deploy: f205a15af732dad396a717e6f1706a171fc8d44f

---
 Cats.html            |  4 ++--
 FeatureOverview.html |  2 +-
 Injection.html       |  8 ++++----
 Job.html             |  4 ++--
 TypedEncoder.html    |  2 +-
 TypedML.html         | 20 ++++++++++----------
 6 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/Cats.html b/Cats.html
index ba1fbd3f2..519c70280 100644
--- a/Cats.html
+++ b/Cats.html
@@ -119,7 +119,7 @@ 
                              Effect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$13163/1874009418@2c520fe6
+//   cats.data.Kleisli$$$Lambda$12264/1008501965@384c6c14
 // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -144,7 +144,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$13163/1874009418@3bc26697 +// cats.data.Kleisli$$$Lambda$12264/1008501965@6c558c47 // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index 80bbd20a0..4bea34b1d 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -682,7 +682,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15401/318557069@309595c0 +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$14487/1441305388@794414f1 val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index 43559ef5f..d0021c05c 100644 --- a/Injection.html +++ b/Injection.html @@ -96,7 +96,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Tue Feb 01 12:22:12 UTC 2022)) +// people: Seq[Person] = List(Person(42, Tue Feb 01 13:32:51 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -109,11 +109,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@539cbf3b
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@44536a57

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@4b55c5d6
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@75972a86

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -146,7 +146,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@77d95687 +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@6dc2e524

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index b80321f9c..d692e1fec 100644 --- a/Job.html +++ b/Job.html @@ -109,7 +109,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@4d72965d +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@7e6a0781 countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -120,7 +120,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@33e63178 +// finalJob: Job[Int] = frameless.Job$$anon$2@7aab4a83

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index a44086e25..0f4c12665 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -138,7 +138,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@4b75a1d2 +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@5e759d11

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index 3c3711c29..ed6b77edf 100644 --- a/TypedML.html +++ b/TypedML.html @@ -131,7 +131,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@7bae123 +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@1c3b77d0 case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -167,10 +167,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@7f84970f +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@6d404721 val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@64c1e428 +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@341b06c

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -236,7 +236,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@1fe1a142 +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@26e5ab02 case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -244,11 +244,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@de6f28 +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@8634699 indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_2f84b2ab5e63 +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_553937b48b93 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@5389fd67 +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@38889e28 case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -262,10 +262,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@42c49d0e +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@6086f394 val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@50bddfa5 +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@6b30f93d

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -296,7 +296,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@23695db5
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@79f52d4c
 
 case class HouseCityPrediction(
   features: Vector,

From aaf2cbd304df911c35c7ef2dbca0f3ad9fb32715 Mon Sep 17 00:00:00 2001
From: pomadchin 
Date: Thu, 10 Feb 2022 17:44:44 +0000
Subject: [PATCH 013/220] deploy: df6dc10b1cc890bbd4132ff59147cb41e418c04c

---
 Cats.html            |  4 ++--
 FeatureOverview.html |  2 +-
 Injection.html       |  8 ++++----
 Job.html             |  4 ++--
 TypedEncoder.html    |  2 +-
 TypedML.html         | 20 ++++++++++----------
 6 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/Cats.html b/Cats.html
index 519c70280..d40f6f092 100644
--- a/Cats.html
+++ b/Cats.html
@@ -119,7 +119,7 @@ 
                              Effect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$12264/1008501965@384c6c14
+//   cats.data.Kleisli$$$Lambda$13212/1665002263@1d67506e
 // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -144,7 +144,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$12264/1008501965@6c558c47 +// cats.data.Kleisli$$$Lambda$13212/1665002263@13f7a378 // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index 4bea34b1d..3cef7ca09 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -682,7 +682,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$14487/1441305388@794414f1 +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15432/1962183872@532a10fa val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index d0021c05c..78c4f591c 100644 --- a/Injection.html +++ b/Injection.html @@ -96,7 +96,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Tue Feb 01 13:32:51 UTC 2022)) +// people: Seq[Person] = List(Person(42, Thu Feb 10 17:44:05 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -109,11 +109,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@44536a57
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@5cfc835e

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@75972a86
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@506d420f

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -146,7 +146,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@6dc2e524 +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@1416c40b

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index d692e1fec..5008b58ce 100644 --- a/Job.html +++ b/Job.html @@ -109,7 +109,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@7e6a0781 +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@2bbe2982 countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -120,7 +120,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@7aab4a83 +// finalJob: Job[Int] = frameless.Job$$anon$2@4c8a21cd

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index 0f4c12665..f9be2108d 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -138,7 +138,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@5e759d11 +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@7cb264dd

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index ed6b77edf..8c87666aa 100644 --- a/TypedML.html +++ b/TypedML.html @@ -131,7 +131,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@1c3b77d0 +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@67e82f2c case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -167,10 +167,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@6d404721 +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@5a473e25 val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@341b06c +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@1a88f10c

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -236,7 +236,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@26e5ab02 +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@478adc52 case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -244,11 +244,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@8634699 +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@7da8ef6 indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_553937b48b93 +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_a78bdd0ca673 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@38889e28 +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@30e9e95c case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -262,10 +262,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@6086f394 +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@736e15cd val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@6b30f93d +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@62973fbe

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -296,7 +296,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@79f52d4c
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@3169b024
 
 case class HouseCityPrediction(
   features: Vector,

From e7ec5ee97a1d12cd932ca5439321749b53183913 Mon Sep 17 00:00:00 2001
From: pomadchin 
Date: Fri, 11 Feb 2022 21:00:29 +0000
Subject: [PATCH 014/220] deploy: ecb4cbf54d998b7693feb24a4784c1663dee9b8e

---
 Cats.html            |  4 ++--
 FeatureOverview.html |  2 +-
 Injection.html       |  8 ++++----
 Job.html             |  4 ++--
 TypedEncoder.html    |  2 +-
 TypedML.html         | 20 ++++++++++----------
 6 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/Cats.html b/Cats.html
index d40f6f092..3c70e89dd 100644
--- a/Cats.html
+++ b/Cats.html
@@ -119,7 +119,7 @@ 
                              Effect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$13212/1665002263@1d67506e
+//   cats.data.Kleisli$$$Lambda$13169/269169701@7a418c48
 // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -144,7 +144,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$13212/1665002263@13f7a378 +// cats.data.Kleisli$$$Lambda$13169/269169701@5722113a // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index 3cef7ca09..a6f729ffa 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -682,7 +682,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15432/1962183872@532a10fa +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15394/1751809047@22db0718 val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index 78c4f591c..14b333d0c 100644 --- a/Injection.html +++ b/Injection.html @@ -96,7 +96,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Thu Feb 10 17:44:05 UTC 2022)) +// people: Seq[Person] = List(Person(42, Fri Feb 11 20:59:54 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -109,11 +109,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@5cfc835e
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@41d88861

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@506d420f
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@405019a2

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -146,7 +146,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@1416c40b +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@54010887

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index 5008b58ce..ee05d9c25 100644 --- a/Job.html +++ b/Job.html @@ -109,7 +109,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@2bbe2982 +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@5add16e9 countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -120,7 +120,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@4c8a21cd +// finalJob: Job[Int] = frameless.Job$$anon$2@3119a856

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index f9be2108d..b23b88a58 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -138,7 +138,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@7cb264dd +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@2e48f83e

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index 8c87666aa..843529913 100644 --- a/TypedML.html +++ b/TypedML.html @@ -131,7 +131,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@67e82f2c +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@2267499 case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -167,10 +167,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@5a473e25 +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@2c92bf9d val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@1a88f10c +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@5498321c

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -236,7 +236,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@478adc52 +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@318ae88e case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -244,11 +244,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@7da8ef6 +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@410ce25d indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_a78bdd0ca673 +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_e9cd4c8dacf4 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@30e9e95c +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@5aff355c case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -262,10 +262,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@736e15cd +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@603e8cf5 val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@62973fbe +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@696d6e4

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -296,7 +296,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@3169b024
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@20aec261
 
 case class HouseCityPrediction(
   features: Vector,

From d87098011d5551ffa2b5aa511005f202a95165d1 Mon Sep 17 00:00:00 2001
From: pomadchin 
Date: Sat, 19 Feb 2022 14:45:25 +0000
Subject: [PATCH 015/220] deploy: f14ecb68a72f988d6231d39fa315d335a69a7778

---
 Cats.html            |  4 ++--
 FeatureOverview.html |  2 +-
 Injection.html       |  8 ++++----
 Job.html             |  4 ++--
 TypedEncoder.html    |  2 +-
 TypedML.html         | 20 ++++++++++----------
 6 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/Cats.html b/Cats.html
index 3c70e89dd..fc102462e 100644
--- a/Cats.html
+++ b/Cats.html
@@ -119,7 +119,7 @@ 
                              Effect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$13169/269169701@7a418c48
+//   cats.data.Kleisli$$$Lambda$13180/1872108260@689a59f1
 // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -144,7 +144,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$13169/269169701@5722113a +// cats.data.Kleisli$$$Lambda$13180/1872108260@492b26cd // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index a6f729ffa..48223d34c 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -682,7 +682,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15394/1751809047@22db0718 +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15389/1106189748@7fb32a98 val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index 14b333d0c..5051e0406 100644 --- a/Injection.html +++ b/Injection.html @@ -96,7 +96,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Fri Feb 11 20:59:54 UTC 2022)) +// people: Seq[Person] = List(Person(42, Sat Feb 19 14:44:48 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -109,11 +109,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@41d88861
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@73287018

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@405019a2
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@450d7c8c

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -146,7 +146,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@54010887 +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@7af9865

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index ee05d9c25..76d77c597 100644 --- a/Job.html +++ b/Job.html @@ -109,7 +109,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@5add16e9 +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@51f4a533 countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -120,7 +120,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@3119a856 +// finalJob: Job[Int] = frameless.Job$$anon$2@4938cf3c

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index b23b88a58..a89025b57 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -138,7 +138,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@2e48f83e +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@12a3fb3d

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index 843529913..dd78beab8 100644 --- a/TypedML.html +++ b/TypedML.html @@ -131,7 +131,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@2267499 +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@3b79cf29 case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -167,10 +167,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@2c92bf9d +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@259987ad val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@5498321c +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@284e0327

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -236,7 +236,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@318ae88e +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@4fb831b9 case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -244,11 +244,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@410ce25d +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@25550f21 indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_e9cd4c8dacf4 +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_f0c16fd488dc val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@5aff355c +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@45f46541 case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -262,10 +262,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@603e8cf5 +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@327d7fb5 val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@696d6e4 +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@3c46a5ba

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -296,7 +296,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@20aec261
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@31679914
 
 case class HouseCityPrediction(
   features: Vector,

From 288ddc47a37bfbcd9ad65cbbb16f95438a243002 Mon Sep 17 00:00:00 2001
From: cchantep 
Date: Thu, 24 Feb 2022 13:18:38 +0000
Subject: [PATCH 016/220] deploy: 689d97e805f2d41b96054747b65257ff9f1b7ffa

---
 Cats.html            |  4 ++--
 FeatureOverview.html |  2 +-
 Injection.html       |  8 ++++----
 Job.html             |  4 ++--
 TypedEncoder.html    |  2 +-
 TypedML.html         | 20 ++++++++++----------
 6 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/Cats.html b/Cats.html
index fc102462e..c9b01ae34 100644
--- a/Cats.html
+++ b/Cats.html
@@ -119,7 +119,7 @@ 
                              Effect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$13180/1872108260@689a59f1
+//   cats.data.Kleisli$$$Lambda$13183/252776912@434a4236
 // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -144,7 +144,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$13180/1872108260@492b26cd +// cats.data.Kleisli$$$Lambda$13183/252776912@73f00395 // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index 48223d34c..f52425965 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -682,7 +682,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15389/1106189748@7fb32a98 +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15414/741908151@597c6821 val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index 5051e0406..c101cf6e7 100644 --- a/Injection.html +++ b/Injection.html @@ -96,7 +96,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Sat Feb 19 14:44:48 UTC 2022)) +// people: Seq[Person] = List(Person(42, Thu Feb 24 13:17:54 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -109,11 +109,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@73287018
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@16e62210

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@450d7c8c
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@3d5376f9

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -146,7 +146,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@7af9865 +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@2cf96928

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index 76d77c597..b351cdc40 100644 --- a/Job.html +++ b/Job.html @@ -109,7 +109,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@51f4a533 +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@1da8cb26 countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -120,7 +120,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@4938cf3c +// finalJob: Job[Int] = frameless.Job$$anon$2@61e70124

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index a89025b57..462c2c97d 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -138,7 +138,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@12a3fb3d +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@7c839fed

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index dd78beab8..32df04719 100644 --- a/TypedML.html +++ b/TypedML.html @@ -131,7 +131,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@3b79cf29 +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@5813d487 case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -167,10 +167,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@259987ad +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@14a323cf val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@284e0327 +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@5daf6edc

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -236,7 +236,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@4fb831b9 +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@485d500 case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -244,11 +244,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@25550f21 +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@2e1ad6fd indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_f0c16fd488dc +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_b2c1ca9681f0 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@45f46541 +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@366d3a35 case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -262,10 +262,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@327d7fb5 +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@7bfe8c48 val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@3c46a5ba +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@51f96be2

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -296,7 +296,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@31679914
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@292ce21e
 
 case class HouseCityPrediction(
   features: Vector,

From d348b33ab78b559941cf26acba04c77cf61d2e78 Mon Sep 17 00:00:00 2001
From: pomadchin 
Date: Wed, 2 Mar 2022 17:12:49 +0000
Subject: [PATCH 017/220] deploy: 69a1b596a707e0ac521a96d3e8200f33c9184da9

---
 Cats.html                       | 39 ++++++++++++++++++++---
 FeatureOverview.html            | 37 ++++++++++++++++++++--
 Injection.html                  | 43 ++++++++++++++++++++++----
 Job.html                        | 39 ++++++++++++++++++++---
 TypedDataFrame.html             | 35 +++++++++++++++++++--
 TypedDatasetVsSparkDataset.html | 35 +++++++++++++++++++--
 TypedEncoder.html               | 37 ++++++++++++++++++++--
 TypedML.html                    | 55 ++++++++++++++++++++++++++-------
 WorkingWithCsvParquetJson.html  | 35 +++++++++++++++++++--
 helium/laika-helium.css         | 34 --------------------
 index.html                      | 35 +++++++++++++++++++--
 site/styles.css                 |  9 ++++++
 12 files changed, 359 insertions(+), 74 deletions(-)
 create mode 100644 site/styles.css

diff --git a/Cats.html b/Cats.html
index c9b01ae34..845dc0d64 100644
--- a/Cats.html
+++ b/Cats.html
@@ -7,10 +7,28 @@
     
     Using Cats with Frameless
     
+      
+    
+      
+    
+      
+    
+      
+    
+      
+    
+      
+    
+      
+    
+      
+    
     
       
     
     
+      
+    
     
       
     
@@ -18,6 +36,7 @@
     
     
     
+    
     
     
     
@@ -35,7 +54,7 @@
         
       
   
-      
+      
       
       
   
@@ -67,6 +86,13 @@
         
                            • Typed Encoders in Frameless
                              • 
       
       
+      
                                
+        
                              • Related Projects
                                • 
+        
+          
                              • cats
                                • 
+        
+      
                              
+
     
 
     
                              
@@ -119,7 +145,7 @@ 
                              Effect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$13183/252776912@434a4236
+//   cats.data.Kleisli$$$Lambda$13077/2094795170@b7636d8
 // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -144,7 +170,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$13183/252776912@73f00395 +// cats.data.Kleisli$$$Lambda$13077/2094795170@681e9736 // ) resultWithDescription.run(spark).unsafeRunSync() @@ -249,9 +275,14 @@

                              Joins< 
                              Map(1 -> 2, 2 -> 3) |+| Map(1 -> 4, 2 -> -1)
 // res19: Map[Int, Int] = Map(1 -> 6, 2 -> 2)
                              +
                              +                               + - \ No newline at end of file + diff --git a/FeatureOverview.html b/FeatureOverview.html index f52425965..54a536946 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -7,10 +7,28 @@ TypedDataset: Feature Overview + + + + + + + + + + + + + + + + + + @@ -18,6 +36,7 @@ + @@ -35,7 +54,7 @@ - + @@ -67,6 +86,13 @@
                            • Typed Encoders in Frameless
                              • +
                                +
                              • Related Projects
                                • + +
                              • cats
                                • + +
                              + - \ No newline at end of file + diff --git a/Injection.html b/Injection.html index c101cf6e7..15d27f42c 100644 --- a/Injection.html +++ b/Injection.html @@ -7,10 +7,28 @@ Injection: Creating Custom Encoders + + + + + + + + + + + + + + + + + + @@ -18,6 +36,7 @@ + @@ -35,7 +54,7 @@ - + @@ -67,6 +86,13 @@
                            • Typed Encoders in Frameless
                              • +
                                +
                              • Related Projects
                                • + +
                              • cats
                                • + +
                              +
                              @@ -96,7 +122,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Thu Feb 24 13:17:54 UTC 2022)) +// people: Seq[Person] = List(Person(42, Wed Mar 02 17:12:10 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -109,11 +135,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@16e62210
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@4fd60ee

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@3d5376f9
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@76d4016

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -146,7 +172,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@2cf96928 +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@2e5522e

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              @@ -159,9 +185,14 @@

                              Another exampleobject B { case object Bar extends Foo }

                              A.Bar and B.Bar will both be encoded as "Bar" thereby breaking the law that invert(apply(x)) == x.

                              +
                              +                               +

                              - \ No newline at end of file + diff --git a/Job.html b/Job.html index b351cdc40..26199292d 100644 --- a/Job.html +++ b/Job.html @@ -7,10 +7,28 @@ Job[A] + + + + + + + + + + + + + + + + + + @@ -18,6 +36,7 @@ + @@ -35,7 +54,7 @@ - + @@ -67,6 +86,13 @@
                            • Typed Encoders in Frameless
                              • +
                                +
                              • Related Projects
                                • + +
                              • cats
                                • + +
                              +
                              @@ -109,7 +135,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@1da8cb26 +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@46071846 countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -120,7 +146,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@61e70124 +// finalJob: Job[Int] = frameless.Job$$anon$2@16b57833

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              @@ -139,9 +165,14 @@

                              More on SparkDelaycats.effect.Sync instance.

                              +
                              +                               +

                              - \ No newline at end of file + diff --git a/TypedDataFrame.html b/TypedDataFrame.html index 120ae7e62..231ef5b52 100644 --- a/TypedDataFrame.html +++ b/TypedDataFrame.html @@ -7,10 +7,28 @@ Proof of Concept: TypedDataFrame + + + + + + + + + + + + + + + + + + @@ -18,6 +36,7 @@ + @@ -35,7 +54,7 @@ - + @@ -67,6 +86,13 @@
                            • Typed Encoders in Frameless
                              • +
                                +
                              • Related Projects
                                • + +
                              • cats
                                • + +
                              + - \ No newline at end of file + diff --git a/TypedDatasetVsSparkDataset.html b/TypedDatasetVsSparkDataset.html index 1a0fc1579..d591d91ed 100644 --- a/TypedDatasetVsSparkDataset.html +++ b/TypedDatasetVsSparkDataset.html @@ -7,10 +7,28 @@ Comparing TypedDatasets with Spark's Datasets + + + + + + + + + + + + + + + + + + @@ -18,6 +36,7 @@ + @@ -35,7 +54,7 @@ - + @@ -67,6 +86,13 @@
                            • Typed Encoders in Frameless
                              • +
                                +
                              • Related Projects
                                • + +
                              • cats
                                • + +
                              +
                              @@ -403,9 +429,14 @@

                              Aggregate vs Projected c // fds.agg(fsum(fds('i)), fds('i)).show().run() // ^^^^^^^ +
                              + +

                              - \ No newline at end of file + diff --git a/TypedEncoder.html b/TypedEncoder.html index 462c2c97d..aac6fd607 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -7,10 +7,28 @@ Typed Encoders in Frameless + + + + + + + + + + + + + + + + + + @@ -18,6 +36,7 @@ + @@ -35,7 +54,7 @@ - + @@ -67,6 +86,13 @@
                            • Typed Encoders in Frameless
                              • +
                                +
                              • Related Projects
                                • + +
                              • cats
                                • + +
                              +
                              @@ -138,7 +164,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@7c839fed +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@c9c66ae

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              @@ -154,9 +180,14 @@

                              Typed Encoders in Frameless

                              It should be noted that once derived, reflection-based Encoders and implicitly derived TypeEncoders have identical performance. The derivation mechanism is different, but the objects generated to encode and decode JVM objects in Spark's internal representation behave the same at runtime.

                              +
                              + +

                              - \ No newline at end of file + diff --git a/TypedML.html b/TypedML.html index 32df04719..add21a52f 100644 --- a/TypedML.html +++ b/TypedML.html @@ -7,10 +7,28 @@ Typed Spark ML + + + + + + + + + + + + + + + + + + @@ -18,6 +36,7 @@ + @@ -35,7 +54,7 @@ - + @@ -67,6 +86,13 @@
                            • Typed Encoders in Frameless
                              • +
                                +
                              • Related Projects
                                • + +
                              • cats
                                • + +
                              +
                              @@ -131,7 +157,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@5813d487 +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@1e323fa7 case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -167,10 +193,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@14a323cf +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@10364d7b val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@5daf6edc +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@57dceb99

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -236,7 +262,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@485d500 +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@32f1e844 case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -244,11 +270,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@2e1ad6fd +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@43f53bd5 indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_b2c1ca9681f0 +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_164d83c9ca38 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@366d3a35 +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@6427f450 case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -262,10 +288,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@7bfe8c48 +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@9bdcb2d val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@51f96be2 +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@34b3b196

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -296,7 +322,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@292ce21e
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@5e721f46
 
 case class HouseCityPrediction(
   features: Vector,
@@ -347,9 +373,14 @@ 
                              Using Vector
         and org.apache.spark.ml.linalg.MatrixUDT. This is possible thanks to the implicit derivation 
         from org.apache.spark.sql.types.UserDefinedType[A] to TypedEncoder[A] defined in TypedEncoder companion object.
                              
 
+        
                              
+                                      
+

                              - \ No newline at end of file + diff --git a/WorkingWithCsvParquetJson.html b/WorkingWithCsvParquetJson.html index 9a6588b4b..8bef6745e 100644 --- a/WorkingWithCsvParquetJson.html +++ b/WorkingWithCsvParquetJson.html @@ -7,10 +7,28 @@ Working with CSV and Parquet data + + + + + + + + + + + + + + + + + + @@ -18,6 +36,7 @@ + @@ -35,7 +54,7 @@ - + @@ -67,6 +86,13 @@
                            • Typed Encoders in Frameless
                              • +
                                +
                              • Related Projects
                                • + +
                              • cats
                                • + +
                              +
                              @@ -234,9 +260,14 @@

                              Dealin // IrisLight("Iris-setosa", 4.9) // ) +
                              + +

                              - \ No newline at end of file + diff --git a/helium/laika-helium.css b/helium/laika-helium.css index 4c2285cd4..b6b265af9 100644 --- a/helium/laika-helium.css +++ b/helium/laika-helium.css @@ -42,40 +42,6 @@ --content-width: 860px; --nav-width: 275px; --top-bar-height: 50px; - color-scheme: light dark; -} - -@media (prefers-color-scheme: dark) { - :root { - --primary-color: #a7d4de; - --primary-light: #125d75; - --primary-medium: #a7d4de; - --secondary-color: #f1c47b; - --text-color: #eeeeee; - --bg-color: #064458; - --gradient-top: #064458; - --gradient-bottom: #197286; - --top-color: var(--primary-color); - --top-bg: var(--primary-light); - --top-hover: var(--secondary-color); - --top-border: var(--primary-medium); - --messages-info: #ebf6f7; - --messages-info-light: #007c99; - --messages-warning: #fcfacd; - --messages-warning-light: #b1a400; - --messages-error: #ffe9e3; - --messages-error-light: #d83030; - --syntax-base1: #2a3236; - --syntax-base2: #8c878e; - --syntax-base3: #b2adb4; - --syntax-base4: #bddcee; - --syntax-base5: #e8e8e8; - --syntax-wheel1: #e28e93; - --syntax-wheel2: #ef9725; - --syntax-wheel3: #ffc66d; - --syntax-wheel4: #7fb971; - --syntax-wheel5: #4dbed4; - } } *, :after, :before { diff --git a/index.html b/index.html index faa61fd82..5c4c8c7ba 100644 --- a/index.html +++ b/index.html @@ -7,10 +7,28 @@ Frameless + + + + + + + + + + + + + + + + + + @@ -18,6 +36,7 @@ + @@ -35,7 +54,7 @@ - + @@ -67,6 +86,13 @@
                            • Typed Encoders in Frameless
                              • +
                                +
                              • Related Projects
                                • + +
                              • cats
                                • + +
                              +
                              @@ -310,9 +336,14 @@

                              Licensehttp://opensource.org/licenses/Apache-2.0, as well as in the LICENSE file. This is the same license used as Spark.

                              +
                              + +

                              - \ No newline at end of file + diff --git a/site/styles.css b/site/styles.css new file mode 100644 index 000000000..267c4a84d --- /dev/null +++ b/site/styles.css @@ -0,0 +1,9 @@ +header img { + height: 40px; + width: auto; + margin-top: 6px; +} + +#sidebar li.nav-header { + margin-top: -20px; +} From ede8cc27e5710ee4143245a4e9d642fdd2ff61e3 Mon Sep 17 00:00:00 2001 From: pomadchin Date: Sat, 5 Mar 2022 23:10:52 +0000 Subject: [PATCH 018/220] deploy: 18fc6d25d573f2558b30d7f3e0ff222150b1e2d8 --- Cats.html | 4 ++-- FeatureOverview.html | 2 +- Injection.html | 8 ++++---- Job.html | 4 ++-- TypedEncoder.html | 2 +- TypedML.html | 20 ++++++++++---------- 6 files changed, 20 insertions(+), 20 deletions(-) diff --git a/Cats.html b/Cats.html index 845dc0d64..488217519 100644 --- a/Cats.html +++ b/Cats.html @@ -145,7 +145,7 @@

                              Effect Suspension i count <- typedDs.count[Action]() } yield (sample, count) // result: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$13077/2094795170@b7636d8 +// cats.data.Kleisli$$$Lambda$12129/827434947@5e85b67f // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -170,7 +170,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$13077/2094795170@681e9736 +// cats.data.Kleisli$$$Lambda$12129/827434947@1c0fad54 // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index 54a536946..0a4b7f05e 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -708,7 +708,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15299/1771240707@42e267ab +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$14354/1680226553@8372253 val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index 15d27f42c..2b004cfa8 100644 --- a/Injection.html +++ b/Injection.html @@ -122,7 +122,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Wed Mar 02 17:12:10 UTC 2022)) +// people: Seq[Person] = List(Person(42, Sat Mar 05 23:10:16 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -135,11 +135,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@4fd60ee
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@321b24a3

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@76d4016
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@78bc20ed

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -172,7 +172,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@2e5522e +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@4cb7a9f0

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index 26199292d..20ab74357 100644 --- a/Job.html +++ b/Job.html @@ -135,7 +135,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@46071846 +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@24d48de7 countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -146,7 +146,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@16b57833 +// finalJob: Job[Int] = frameless.Job$$anon$2@128036

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index aac6fd607..6dbfe1ea6 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -164,7 +164,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@c9c66ae +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@3f89d3b9

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index add21a52f..5b817e183 100644 --- a/TypedML.html +++ b/TypedML.html @@ -157,7 +157,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@1e323fa7 +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@1b2c62f case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -193,10 +193,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@10364d7b +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@19e868bb val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@57dceb99 +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@7ee016b5

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -262,7 +262,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@32f1e844 +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@46d375b4 case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -270,11 +270,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@43f53bd5 +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@7c7ec618 indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_164d83c9ca38 +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_220623b3c749 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@6427f450 +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@4ecf9d93 case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -288,10 +288,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@9bdcb2d +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@45628d55 val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@34b3b196 +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@18c13e98

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -322,7 +322,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@5e721f46
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@1205759e
 
 case class HouseCityPrediction(
   features: Vector,

From 9f391ff583b4693dd60e03e9268ad3f72d0e2192 Mon Sep 17 00:00:00 2001
From: pomadchin 
Date: Sun, 6 Mar 2022 00:01:43 +0000
Subject: [PATCH 019/220] deploy: 18fc6d25d573f2558b30d7f3e0ff222150b1e2d8

---
 Cats.html            |  4 ++--
 FeatureOverview.html |  2 +-
 Injection.html       |  8 ++++----
 Job.html             |  4 ++--
 TypedEncoder.html    |  2 +-
 TypedML.html         | 20 ++++++++++----------
 6 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/Cats.html b/Cats.html
index 488217519..8d5638846 100644
--- a/Cats.html
+++ b/Cats.html
@@ -145,7 +145,7 @@ 
                              Effect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$12129/827434947@5e85b67f
+//   cats.data.Kleisli$$$Lambda$12202/766085592@388dbee
 // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -170,7 +170,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$12129/827434947@1c0fad54 +// cats.data.Kleisli$$$Lambda$12202/766085592@66114537 // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index 0a4b7f05e..52a0a5099 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -708,7 +708,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$14354/1680226553@8372253 +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$14418/1080127787@3c046717 val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index 2b004cfa8..4e37e6a03 100644 --- a/Injection.html +++ b/Injection.html @@ -122,7 +122,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Sat Mar 05 23:10:16 UTC 2022)) +// people: Seq[Person] = List(Person(42, Sun Mar 06 00:00:58 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -135,11 +135,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@321b24a3
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@494c81bd

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@78bc20ed
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@386423d2

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -172,7 +172,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@4cb7a9f0 +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@2cbb4084

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index 20ab74357..31dd2948c 100644 --- a/Job.html +++ b/Job.html @@ -135,7 +135,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@24d48de7 +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@143c54d6 countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -146,7 +146,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@128036 +// finalJob: Job[Int] = frameless.Job$$anon$2@a61d832

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index 6dbfe1ea6..74d5a9575 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -164,7 +164,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@3f89d3b9 +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@d951782

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index 5b817e183..dd1223c6c 100644 --- a/TypedML.html +++ b/TypedML.html @@ -157,7 +157,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@1b2c62f +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@7b21b406 case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -193,10 +193,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@19e868bb +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@38b5dc75 val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@7ee016b5 +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@d595cbc

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -262,7 +262,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@46d375b4 +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@a1e7e41 case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -270,11 +270,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@7c7ec618 +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@28c8ea2b indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_220623b3c749 +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_5121214aed35 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@4ecf9d93 +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@513ce6e8 case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -288,10 +288,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@45628d55 +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@462b7f6f val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@18c13e98 +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@3f3eed9d

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -322,7 +322,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@1205759e
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@50c8d1e3
 
 case class HouseCityPrediction(
   features: Vector,

From 7313b424eff39aa664dbbf3ce7df41f35c93d43f Mon Sep 17 00:00:00 2001
From: pomadchin 
Date: Sun, 6 Mar 2022 03:08:54 +0000
Subject: [PATCH 020/220] deploy: 18fc6d25d573f2558b30d7f3e0ff222150b1e2d8

---
 Cats.html            |  4 ++--
 FeatureOverview.html |  2 +-
 Injection.html       |  8 ++++----
 Job.html             |  4 ++--
 TypedEncoder.html    |  2 +-
 TypedML.html         | 20 ++++++++++----------
 6 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/Cats.html b/Cats.html
index 8d5638846..e8bb27eef 100644
--- a/Cats.html
+++ b/Cats.html
@@ -145,7 +145,7 @@ 
                              Effect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$12202/766085592@388dbee
+//   cats.data.Kleisli$$$Lambda$12142/920802469@1b17fdab
 // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -170,7 +170,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$12202/766085592@66114537 +// cats.data.Kleisli$$$Lambda$12142/920802469@796c6001 // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index 52a0a5099..24bd93f0c 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -708,7 +708,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$14418/1080127787@3c046717 +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$14353/563407826@20c6d16a val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index 4e37e6a03..e5de32bd5 100644 --- a/Injection.html +++ b/Injection.html @@ -122,7 +122,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Sun Mar 06 00:00:58 UTC 2022)) +// people: Seq[Person] = List(Person(42, Sun Mar 06 03:08:18 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -135,11 +135,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@494c81bd
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@19bda9fd

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@386423d2
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@56135056

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -172,7 +172,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@2cbb4084 +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@45a852eb

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index 31dd2948c..54eb6967a 100644 --- a/Job.html +++ b/Job.html @@ -135,7 +135,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@143c54d6 +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@66858ec6 countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -146,7 +146,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@a61d832 +// finalJob: Job[Int] = frameless.Job$$anon$2@43426377

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index 74d5a9575..85f1ab393 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -164,7 +164,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@d951782 +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@9f1f9ff

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index dd1223c6c..757e037fb 100644 --- a/TypedML.html +++ b/TypedML.html @@ -157,7 +157,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@7b21b406 +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@34c80dbf case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -193,10 +193,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@38b5dc75 +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@29824a08 val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@d595cbc +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@437c79cd

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -262,7 +262,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@a1e7e41 +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@1a37cc3 case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -270,11 +270,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@28c8ea2b +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@af25f12 indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_5121214aed35 +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_1366a7510e50 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@513ce6e8 +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@67ae280 case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -288,10 +288,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@462b7f6f +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@3f6bf993 val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@3f3eed9d +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@25b4cfd9

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -322,7 +322,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@50c8d1e3
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@3da60eb2
 
 case class HouseCityPrediction(
   features: Vector,

From e7cb1ed68b5def22b1aa44311f15f80f9197849b Mon Sep 17 00:00:00 2001
From: pomadchin 
Date: Sun, 6 Mar 2022 03:54:46 +0000
Subject: [PATCH 021/220] deploy: 18fc6d25d573f2558b30d7f3e0ff222150b1e2d8

---
 Cats.html            |  4 ++--
 FeatureOverview.html |  2 +-
 Injection.html       |  8 ++++----
 Job.html             |  4 ++--
 TypedEncoder.html    |  2 +-
 TypedML.html         | 20 ++++++++++----------
 6 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/Cats.html b/Cats.html
index e8bb27eef..9fe410500 100644
--- a/Cats.html
+++ b/Cats.html
@@ -145,7 +145,7 @@ 
                              Effect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$12142/920802469@1b17fdab
+//   cats.data.Kleisli$$$Lambda$12217/1354641235@33aad24b
 // )

                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To run our program, we must first supply the SparkSession to the ReaderT layer and then @@ -170,7 +170,7 @@

                              yield r // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli( -// cats.data.Kleisli$$$Lambda$12142/920802469@796c6001 +// cats.data.Kleisli$$$Lambda$12217/1354641235@2461e7f5 // ) resultWithDescription.run(spark).unsafeRunSync() diff --git a/FeatureOverview.html b/FeatureOverview.html index 24bd93f0c..c565c2f74 100644 --- a/FeatureOverview.html +++ b/FeatureOverview.html @@ -708,7 +708,7 @@

                              User Defined Functions// priceModifier: (String, Double) => Double = <function2> val udf = aptTypedDs.makeUDF(priceModifier) -// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$14353/563407826@20c6d16a +// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$14446/1414844303@3b4032b1 val aptds = aptTypedDs // For shorter expressions // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions diff --git a/Injection.html b/Injection.html index e5de32bd5..e11ac9421 100644 --- a/Injection.html +++ b/Injection.html @@ -122,7 +122,7 @@

                              Examplecase class Person(age: Int, birthday: java.util.Date) val people = Seq(Person(42, new java.util.Date)) -// people: Seq[Person] = List(Person(42, Sun Mar 06 03:08:18 UTC 2022)) +// people: Seq[Person] = List(Person(42, Sun Mar 06 03:54:05 UTC 2022))

                              And an instance of a TypedDataset:

                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -135,11 +135,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@19bda9fd
                              +// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@32ff9ed1

                              We can be less verbose using the Injection.apply function:

                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@56135056
                              +// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@63dbcb78

                              Now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              @@ -172,7 +172,7 @@

                              Another examplecase 2 => Female case 3 => Other }) -// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@45a852eb +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@b41e45f

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index 54eb6967a..87fb4684f 100644 --- a/Job.html +++ b/Job.html @@ -135,7 +135,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@66858ec6 +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@3e9062fe countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -146,7 +146,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@43426377 +// finalJob: Job[Int] = frameless.Job$$anon$2@3c14a657

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index 85f1ab393..7da3e8413 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -164,7 +164,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@9f1f9ff +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@2916a1a8

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index 757e037fb..ef7c573aa 100644 --- a/TypedML.html +++ b/TypedML.html @@ -157,7 +157,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@34c80dbf +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@13bd83fa case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -193,10 +193,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@29824a08 +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@392f1960 val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@437c79cd +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@a6615d9

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -262,7 +262,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@1a37cc3 +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@4f758138 case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -270,11 +270,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@af25f12 +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@7405c3c4 indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_1366a7510e50 +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_01ecccb7abe7 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@67ae280 +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@5c0bf46d case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -288,10 +288,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@3f6bf993 +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@3f37bdf1 val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@25b4cfd9 +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@5c28976e

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -322,7 +322,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@3da60eb2
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@6e974cc
 
 case class HouseCityPrediction(
   features: Vector,

From 8809a3436f92028a97b5bd4ab4320e4b1e97f7f2 Mon Sep 17 00:00:00 2001
From: pomadchin 
Date: Tue, 15 Mar 2022 19:34:32 +0000
Subject: [PATCH 022/220] deploy: 5d81a2b5a9bb92ddff45b4903703d33cb22e2ebe

---
 Cats.html            | 32 +++++++++++++------------
 FeatureOverview.html |  2 +-
 Injection.html       |  8 +++----
 Job.html             |  4 ++--
 TypedEncoder.html    |  2 +-
 TypedML.html         | 20 ++++++++--------
 index.html           | 57 +++++++++++++++++++++++++-------------------
 7 files changed, 68 insertions(+), 57 deletions(-)

diff --git a/Cats.html b/Cats.html
index 9fe410500..d8452df42 100644
--- a/Cats.html
+++ b/Cats.html
@@ -118,15 +118,15 @@ 
                              Using Cats with Frameless
                              
         - RDD enhancements using algebraic typeclasses in cats-kernel
                              
         
                              All the examples below assume you have previously imported cats.implicits and frameless.cats.implicits.
                              
         
                              Note that you should not import frameless.syntax._ together with frameless.cats.implicits._.
                              
-        
                              import cats.implicits._
+        
                              import cats.syntax.all._
 import frameless.cats.implicits._
                              
         
         
                              Effect Suspension in typed datasets
                              
-        
                              As noted in the section about Job, all operations on TypedDataset are lazy. The results of 
-        operations that would normally block on plain Spark APIs are wrapped in a type constructor F[_], 
-        for which there exists an instance of SparkDelay[F]. This typeclass represents the operation of 
-        delaying a computation and capturing an implicit SparkSession. 
                              
-        
                              In the cats module, we utilize the typeclasses from cats-effect for abstracting over these 
+        
                              As noted in the section about Job, all operations on TypedDataset are lazy. The results of
+        operations that would normally block on plain Spark APIs are wrapped in a type constructor F[_],
+        for which there exists an instance of SparkDelay[F]. This typeclass represents the operation of
+        delaying a computation and capturing an implicit SparkSession.
                              
+        
                              In the cats module, we utilize the typeclasses from cats-effect for abstracting over these
         effect types - namely, we provide an implicit SparkDelay instance for all F[_] for which exists
         an instance of cats.effect.Sync[F].
                              
         
                              This allows one to run operations on TypedDataset in an existing monad stack. For example, given
@@ -145,12 +145,14 @@ 
                              Effect Suspension i
   count <- typedDs.count[Action]()
 } yield (sample, count)
 // result: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$12217/1354641235@33aad24b
+//   cats.data.Kleisli$$$Lambda$13050/1169762347@62de2665
 // )
                              
         
                              As with Job, note that nothing has been run yet. The effect has been properly suspended. To
         run our program, we must first supply the SparkSession to the ReaderT layer and then
         run the IO effect:
                              
-        
                              result.run(spark).unsafeRunSync()
+        
                              import cats.effect.unsafe.implicits.global
+
+result.run(spark).unsafeRunSync()
 // res5: (Seq[(Int, String)], Long) = (WrappedArray((1, "string")), 2L)
                              
         
         
                              Convenience methods for modifying Spark thread-local variables
                              
@@ -170,7 +172,7 @@ 
                              yield r
 // resultWithDescription: Action[(Seq[(Int, String)], Long)] = Kleisli(
-//   cats.data.Kleisli$$$Lambda$12217/1354641235@2461e7f5
+//   cats.data.Kleisli$$$Lambda$13050/1169762347@7fd30cf7
 // )
 
 resultWithDescription.run(spark).unsafeRunSync()
@@ -186,7 +188,7 @@ 
                              Using a
         
                              import frameless.cats.implicits._
 
 val data: RDD[(Int, Int, Int)] = sc.makeRDD((1, 2, 3) :: (1, 5, 3) :: (8, 2, 3) :: Nil)
-// data: RDD[(Int, Int, Int)] = ParallelCollectionRDD[12] at makeRDD at Cats.md:127
+// data: RDD[(Int, Int, Int)] = ParallelCollectionRDD[12] at makeRDD at Cats.md:130
 
 println(data.csum)
 // (10,9,9)
@@ -198,7 +200,7 @@ 
                              Using a
         elements inside the RDD. There are counterpart operations to those that have an Option return type
         to deal with the case of an empty RDD:
                              
         
                              val data: RDD[(Int, Int, Int)] = sc.emptyRDD
-// data: RDD[(Int, Int, Int)] = EmptyRDD[13] at emptyRDD at Cats.md:143
+// data: RDD[(Int, Int, Int)] = EmptyRDD[13] at emptyRDD at Cats.md:146
 
 println(data.csum)
 // (0,0,0)
@@ -218,7 +220,7 @@ 
                              Using a
 
 val allData: RDD[(User,TransactionCount)] =
    sc.makeRDD(("Bob", 12) :: ("Joe", 1) :: ("Anna", 100) :: ("Bob", 20) :: ("Joe", 2) :: Nil)
-// allData: RDD[(User, TransactionCount)] = ParallelCollectionRDD[14] at makeRDD at Cats.md:174
+// allData: RDD[(User, TransactionCount)] = ParallelCollectionRDD[14] at makeRDD at Cats.md:177
 
 val totalPerUser =  allData.csumByKey
 // totalPerUser: RDD[(User, TransactionCount)] = ShuffledRDD[15] at reduceByKey at implicits.scala:42
@@ -235,7 +237,7 @@ 
                              Using a
 val allDataComplexKeu =
    sc.makeRDD( ("Bob", SortedMap("task1" -> 10)) ::
     ("Joe", SortedMap("task1" -> 1, "task2" -> 3)) :: ("Bob", SortedMap("task1" -> 10, "task2" -> 1)) :: ("Joe", SortedMap("task3" -> 4)) :: Nil )
-// allDataComplexKeu: RDD[(String, SortedMap[String, Int])] = ParallelCollectionRDD[16] at makeRDD at Cats.md:190
+// allDataComplexKeu: RDD[(String, SortedMap[String, Int])] = ParallelCollectionRDD[16] at makeRDD at Cats.md:193
 
 val overalTasksPerUser = allDataComplexKeu.csumByKey
 // overalTasksPerUser: RDD[(String, SortedMap[String, Int])] = ShuffledRDD[17] at reduceByKey at implicits.scala:42
@@ -254,9 +256,9 @@ 
                              Joins<
         
                              import frameless.cats.outer._
 
 val day1: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 2, 1 -> 4)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Sam", Map(0 -> 1)) :: Nil )
-// day1: RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[18] at makeRDD at Cats.md:215
+// day1: RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[18] at makeRDD at Cats.md:218
 val day2: RDD[(UserName,TimeSeries)] = sc.makeRDD( ("John", Map(0 -> 10, 1 -> 11)) :: ("Chris", Map(0 -> 1, 1 -> 2)) :: ("Joe", Map(0 -> 1, 1 -> 2)) :: Nil )
-// day2: RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[19] at makeRDD at Cats.md:218
+// day2: RDD[(UserName, TimeSeries)] = ParallelCollectionRDD[19] at makeRDD at Cats.md:221
 
 val daysCombined = day1 |+| day2
 // daysCombined: RDD[(UserName, TimeSeries)] = MapPartitionsRDD[23] at mapValues at implicits.scala:67
diff --git a/FeatureOverview.html b/FeatureOverview.html
index c565c2f74..8579adf04 100644
--- a/FeatureOverview.html
+++ b/FeatureOverview.html
@@ -708,7 +708,7 @@ 
                              User Defined Functions// priceModifier: (String, Double) => Double = <function2>
 
 val udf = aptTypedDs.makeUDF(priceModifier)
-// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$14446/1414844303@3b4032b1
+// udf: (frameless.TypedColumn[Apartment, String], frameless.TypedColumn[Apartment, Double]) => frameless.TypedColumn[Apartment, Double] = frameless.functions.Udf$$Lambda$15310/187241253@4025a631
 
 val aptds = aptTypedDs // For shorter expressions
 // aptds: TypedDataset[Apartment] = [city: string, surface: int ... 2 more fields] // For shorter expressions
diff --git a/Injection.html b/Injection.html
index e11ac9421..c88f32dc4 100644
--- a/Injection.html
+++ b/Injection.html
@@ -122,7 +122,7 @@ 
                              Examplecase class Person(age: Int, birthday: java.util.Date)
 val people = Seq(Person(42, new java.util.Date))
-// people: Seq[Person] = List(Person(42, Sun Mar 06 03:54:05 UTC 2022))
                              
+// people: Seq[Person] = List(Person(42, Tue Mar 15 19:33:54 UTC 2022))
                              
         
                              And an instance of a TypedDataset:
                              
         
                              val personDS = TypedDataset.create(people)
 // error: could not find implicit value for parameter encoder: frameless.TypedEncoder[repl.MdocSession.App0.Person]
@@ -135,11 +135,11 @@ 
                              Exampledef apply(d: java.util.Date): Long = d.getTime()
   def invert(l: Long): java.util.Date = new java.util.Date(l)
 }
-// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@32ff9ed1
                              
+// dateToLongInjection: AnyRef with Injection[java.util.Date, Long] = repl.MdocSession$App0$$anon$1@5c51349c
                              
         
                              We can be less verbose using the Injection.apply function:
                              
         
                              import frameless._
 implicit val dateToLongInjection = Injection((_: java.util.Date).getTime(), new java.util.Date((_: Long)))
-// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@63dbcb78
                              
+// dateToLongInjection: Injection[java.util.Date, Long] = frameless.Injection$$anon$1@18d2a403
                              
         
                              Now we can create our TypedDataset:
                              
         
                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, birthday: bigint]
                              
@@ -172,7 +172,7 @@ 
                              Another examplecase 2 => Female
     case 3 => Other
   })
-// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@b41e45f
                              +// genderToInt: Injection[Gender, Int] = frameless.Injection$$anon$1@25b99a28

                              And now we can create our TypedDataset:

                              val personDS = TypedDataset.create(people)
 // personDS: TypedDataset[Person] = [age: int, gender: int]
                              diff --git a/Job.html b/Job.html index 87fb4684f..c802ebb73 100644 --- a/Job.html +++ b/Job.html @@ -135,7 +135,7 @@

                              Job[A]

                              count <- ds.count() sample <- ds.take((count/5).toInt) } yield sample -// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@3e9062fe +// countAndTakeJob: frameless.Job[Seq[Int]] = frameless.Job$$anon$3@5ed51743 countAndTakeJob.run() // res1: Seq[Int] = WrappedArray(1, 2, 3, 4) @@ -146,7 +146,7 @@

                              Job[A]

                              def computeMinOfSample(sample: Job[Seq[Int]]): Job[Int] = sample.map(_.min) val finalJob = computeMinOfSample(countAndTakeJob) -// finalJob: Job[Int] = frameless.Job$$anon$2@3c14a657 +// finalJob: Job[Int] = frameless.Job$$anon$2@41577fb4

                              Now we can execute this new job by specifying a group-id and a description. This allows the programmer to see this information on the Spark UI and help track, say, performance issues.

                              diff --git a/TypedEncoder.html b/TypedEncoder.html index 7da3e8413..5987ca686 100644 --- a/TypedEncoder.html +++ b/TypedEncoder.html @@ -164,7 +164,7 @@

                              Typed Encoders in Framelessval ds: TypedDataset[Foo] = TypedDataset.create(Seq(Foo(1, Bar(1.1, "s")))) // ds: TypedDataset[Foo] = [i: int, b: struct<d: double, s: string>] ds.collect() -// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@2916a1a8 +// res3: frameless.Job[Seq[Foo]] = frameless.Job$$anon$4@e125155

                              But any non-encodable in the case class hierarchy will be detected at compile time:

                              case class BarDate(d: Double, s: String, t: java.util.Date)
 case class FooDate(i: Int, b: BarDate)
                              diff --git a/TypedML.html b/TypedML.html index ef7c573aa..2ecbf49ce 100644 --- a/TypedML.html +++ b/TypedML.html @@ -157,7 +157,7 @@

                              Trainingcase class Features(squareFeet: Double, hasGarden: Boolean) val assembler = TypedVectorAssembler[Features] -// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@13bd83fa +// assembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@7e33ee61 case class HouseDataWithFeatures(squareFeet: Double, hasGarden: Boolean, price: Double, features: Vector) val trainingDataWithFeatures = assembler.transform(trainingData).as[HouseDataWithFeatures] @@ -193,10 +193,10 @@

                              Trainingcase class RFInputs(price: Double, features: Vector) val rf = TypedRandomForestRegressor[RFInputs] -// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@392f1960 +// rf: TypedRandomForestRegressor[RFInputs] = frameless.ml.regression.TypedRandomForestRegressor@2790c50f val model = rf.fit(trainingDataWithFeatures).run() -// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@a6615d9 +// model: AppendTransformer[RFInputs, TypedRandomForestRegressor.Outputs, org.apache.spark.ml.regression.RandomForestRegressionModel] = frameless.ml.TypedEstimator$$anon$1@3c34093e

                              TypedRandomForestRegressor[RFInputs] compiles only if RFInputs contains only one field of type Double (the label) and one field of type Vector (the features):

                              case class WrongRFInputs(labelOfWrongType: String, features: Vector)
                              @@ -262,7 +262,7 @@

                              Trainingcase class Features(price: Double, squareFeet: Double) val vectorAssembler = TypedVectorAssembler[Features] -// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@4f758138 +// vectorAssembler: TypedVectorAssembler[Features] = frameless.ml.feature.TypedVectorAssembler@294590da case class HouseDataWithFeatures(squareFeet: Double, city: String, price: Double, features: Vector) val dataWithFeatures = vectorAssembler.transform(trainingData).as[HouseDataWithFeatures] @@ -270,11 +270,11 @@

                              Trainingcase class StringIndexerInput(city: String) val indexer = TypedStringIndexer[StringIndexerInput] -// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@7405c3c4 +// indexer: TypedStringIndexer[StringIndexerInput] = frameless.ml.feature.TypedStringIndexer@178eab21 indexer.estimator.setHandleInvalid("keep") -// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_01ecccb7abe7 +// res12: org.apache.spark.ml.feature.StringIndexer = strIdx_a5a589549ca6 val indexerModel = indexer.fit(dataWithFeatures).run() -// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@5c0bf46d +// indexerModel: AppendTransformer[StringIndexerInput, TypedStringIndexer.Outputs, org.apache.spark.ml.feature.StringIndexerModel] = frameless.ml.TypedEstimator$$anon$1@22d40177 case class HouseDataWithFeaturesAndIndex( squareFeet: Double, @@ -288,10 +288,10 @@

                              Trainingcase class RFInputs(cityIndexed: Double, features: Vector) val rf = TypedRandomForestClassifier[RFInputs] -// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@3f37bdf1 +// rf: TypedRandomForestClassifier[RFInputs] = frameless.ml.classification.TypedRandomForestClassifier@41b09b1b val model = rf.fit(indexedData).run() -// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@5c28976e +// model: AppendTransformer[RFInputs, TypedRandomForestClassifier.Outputs, org.apache.spark.ml.classification.RandomForestClassificationModel] = frameless.ml.TypedEstimator$$anon$1@44f610b7

                              Prediction

                              We now want to predict city for testData using the previously trained model. Like the Spark ML API, @@ -322,7 +322,7 @@

                              PredictionindexerModel:

                              case class IndexToStringInput(predictedCityIndexed: Double)
 val indexToString = TypedIndexToString[IndexToStringInput](indexerModel.transformer.labels)
-// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@6e974cc
+// indexToString: TypedIndexToString[IndexToStringInput] = frameless.ml.feature.TypedIndexToString@26c37cab
 
 case class HouseCityPrediction(
   features: Vector,
diff --git a/index.html b/index.html
index 5c4c8c7ba..17b24e2e3 100644
--- a/index.html
+++ b/index.html
@@ -123,10 +123,10 @@ 
                              Frameless
                              
                                       Discord Badge
         Maven Badge
         Snapshots Badge
                              
-        
                              Frameless is a Scala library for working with Spark using more expressive types. 
+        
                              Frameless is a Scala library for working with Spark using more expressive types.
         It consists of the following modules:
                              
         
                                
-          
                              • frameless-dataset for a more strongly typed Dataset/DataFrame API 
                                • 
+          
                              • frameless-dataset for a more strongly typed Dataset/DataFrame API
                                • 
           
                              • frameless-ml for a more strongly typed Spark ML API based on frameless-dataset
                                • 
           
                              • frameless-cats for using Spark's RDD API with cats
                                • 
         
                              
@@ -137,8 +137,8 @@ 
                              Frameless
                              
         associated channels (e.g. GitHub, Discord) to be a safe and friendly environment for contributing and learning.
                              
         
         
                              Versions and dependencies
                              
-        
                              The compatible versions of Spark and 
-        cats are as follows: 
                              
+        
                              The compatible versions of Spark and
+        cats are as follows:
                              
         
@@ -220,45 +220,54 @@ 
                              Versions and dependencies2.x
               
                              
+            
+              
+              
+              
+              
+              
+            
                              
           
             
                              2.12 / 2.13
             
                              0.12.03.2.0 / 3.1.2 / 3.0.12.x3.x2.12 / 2.13
                              
           
         
                              
         
                              * 0.11.0 has broken Spark 3.1.2 and 3.0.1 artifacts published.
                              
-        
                              Starting 0.11 we introduced Spark cross published artifacts: 
-        * By default, frameless artifacts depend on the most recent Spark version
-        * Suffix -spark{major}{minor} is added to artifacts that are released for the previous Spark version(s)
                              
+        
                              Starting 0.11 we introduced Spark cross published artifacts:
                              
+        
                                
+          
                              • By default, frameless artifacts depend on the most recent Spark version
                                • 
+          
                              • Suffix -spark{major}{minor} is added to artifacts that are released for the previous Spark version(s)
                                • 
+        
                              
         
                              Artifact names examples:
                              
         
                                
           
                              • frameless-dataset (the latest Spark dependency)
                                • 
           
                              • frameless-dataset-spark31 (Spark 3.1.x dependency)
                                • 
           
                              • frameless-dataset-spark30 (Spark 3.0.x dependency)
                                • 
         
                              
-        
                              Versions 0.5.x and 0.6.x have identical features. The first is compatible with Spark 2.2.1 and the second with 2.3.0. 
                              
-        
                              The only dependency of the frameless-dataset module is on shapeless 2.3.2. 
-        Therefore, depending on frameless-dataset, has a minimal overhead on your Spark's application jar. 
-        Only the frameless-cats module depends on cats and cats-effect, so if you prefer to work just with Datasets and not with RDDs, 
-        you may choose not to depend on frameless-cats. 
                              
-        
                              Frameless intentionally does not have a compile dependency on Spark. 
-        This essentially allows you to use any version of Frameless with any version of Spark. 
-        The aforementioned table simply provides the versions of Spark we officially compile 
-        and test Frameless with, but other versions may probably work as well. 
                              
+        
                              Versions 0.5.x and 0.6.x have identical features. The first is compatible with Spark 2.2.1 and the second with 2.3.0.
                              
+        
                              The only dependency of the frameless-dataset module is on shapeless 2.3.2.
+        Therefore, depending on frameless-dataset, has a minimal overhead on your Spark's application jar.
+        Only the frameless-cats module depends on cats and cats-effect, so if you prefer to work just with Datasets and not with RDDs,
+        you may choose not to depend on frameless-cats.
                              
+        
                              Frameless intentionally does not have a compile dependency on Spark.
+        This essentially allows you to use any version of Frameless with any version of Spark.
+        The aforementioned table simply provides the versions of Spark we officially compile
+        and test Frameless with, but other versions may probably work as well.
                              
         
         
                              Breaking changes in 0.9
                              
         
                                
-          
                              • Spark 3 introduces a new ExpressionEncoder approach, the schema for single value DataFrame's is now "value" not "_1".
                                • 
+          
                              • Spark 3 introduces a new ExpressionEncoder approach, the schema for single value DataFrame's is now "value" not "_1".
                                • 
         
                              
         
         
                              Why?
                              
-        
                              Frameless introduces a new Spark API, called TypedDataset. 
+        
                              Frameless introduces a new Spark API, called TypedDataset.
         The benefits of using TypedDataset compared to the standard Spark Dataset API are as follows:
                              
         
                                
           
                              • Typesafe columns referencing (e.g., no more runtime errors when accessing non-existing columns)
                                • 
-          
                              • Customizable, typesafe encoders (e.g., if a type does not have an encoder, it should not compile) 
                                • 
-          
                              • Enhanced type signature for built-in functions (e.g., if you apply an arithmetic operation on a non-numeric column, you 
+          
                              • Customizable, typesafe encoders (e.g., if a type does not have an encoder, it should not compile)
                                • 
+          
                              • Enhanced type signature for built-in functions (e.g., if you apply an arithmetic operation on a non-numeric column, you
           get a compilation error)
                                • 
           
                              • Typesafe casting and projections
                                • 
         
                              
-        
                              Click here for a 
-        detailed comparison of TypedDataset with Spark's Dataset API. 
                              
+        
                              Click here for a
+        detailed comparison of TypedDataset with Spark's Dataset API.
                              
         
         
                              Documentation

                              An easy way to bootstrap a Frameless sbt project: